package com.sg.service.biz.framework.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.framework.req.QueryBaseChangeColDetailReq;
import com.sg.dto.base.framework.req.QueryBaseChangeColListReq;
import com.sg.dto.biz.framework.common.BaseChangeColDto;
import com.sg.dto.biz.framework.req.*;
import com.sg.dto.biz.framework.res.*;
import com.sg.entity.ChangeColumn;
import com.sg.entity.Dept;
import com.sg.entity.InductionRecord;
import com.sg.service.base.framework.*;
import com.sg.service.biz.framework.InductionRecordService;
import com.wicket.okrframework.common.annotations.BanAuto;
import com.sg.common.exception.Assert;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class ChangeColumnServiceImpl
        implements com.wicket.okrframework.biz.service.ChangeColumnService {

    @Resource
    private RedisUtil redisUtil;
    // @Resource
    // private MSpecMethordTableService mSpecMethordTableService;
    @Resource
    private MChangeColumnService mChangeColumnService;
    @Resource
    private DataSource dataSource;
    @Resource
    private NbChangeColumn nbChangeColumn;
    @Resource
    private MInductionRecordService mInductionRecordService;
    @Resource
    private MPositionService mPositionService;
    @Resource
    private InductionRecordService inductionRecordService;
    @Resource
    private MBatchService mBatchService;
    @Resource
    private MDeptService mDeptService;
//@Resource
    //private MCustomFields2Service mCustomFields2Service;
//@Resource
    //private undefinedService undefinedService;

    /**
     * D1-1撤销修订底层框架服务变更字段[918]
     * gen by moon at 10/2/2022, 7:50:23 AM
     */
    @Trace(operationName = "D1-1撤销修订底层框架服务变更字段")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UndoReviseBaseChangeColRespDto undoReviseBaseChangeCol(UndoReviseBaseChangeColReqDto reqDto) {


        //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:47652_1
        queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:47651_1
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:151900_1
        if (reqDto != null) {
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:47649_1
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:47650_1
        }

        /*1-1-02查询修订的变更记录[8]   */
        Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(), "D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getEntityId(), "D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getIsInproperties(), "D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
        Assert.isTrue(listChangeColumn == null || listChangeColumn == null || listChangeColumn.size() == 0, "返回值不能为空", false);


//步骤1: 1-1-02批量删除底层框架服务变更字段 - batchDeleteBaseChangeColumn
        boolean bOOLEAN;
        if (listChangeColumn != null && listChangeColumn.size() > 0) {
            List<String> listString = new ArrayList<>();
            listString = listChangeColumn.stream().map(item -> item.getChangeColumnId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:47655_1

            /*1-1-02批量删除修订的变更记录[7]   */

            bOOLEAN = mChangeColumnService.batchDeleteBaseChangeColumn(listString);


        }

        UndoReviseBaseChangeColRespDto retData = new UndoReviseBaseChangeColRespDto();


        return retData;
    }

    /**
     * D1-1修订底层框架服务变更字段[272]
     * gen by moon at 9/1/2022, 9:47:33 PM
     */
    @Trace(operationName = "D1-1修订底层框架服务变更字段")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReviseBaseChangeColRespDto reviseBaseChangeCol(ReviseBaseChangeColReqDto reqDto) {


        //virtualUsage 1-1-02查底层当前有效变更字段列表  9397
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:152922_1_9397
        queryBaseChangeColListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:152920_1_9397
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:152917_1_9397
        if (reqDto != null) {
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:152914_1_9397
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//sourceId:152915_1_9397
        }

        /*1-1-02查底层当前有效变更字段列表[8]   */
        Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(), "D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getEntityId(), "D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getIsInproperties(), "D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


        if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
            //if(D1-1修订底层框架服务变更字段.主体生命周期 等于 正在编辑)  9421

            boolean bOOLEAN;
            if (listChangeColumn != null && listChangeColumn.size() > 0) {
                List<ChangeColumn> listChangeColumn_2 = new ArrayList<>();
                for (ChangeColumn item : listChangeColumn) {
                    ChangeColumn oneItem = new ChangeColumn();
                    oneItem.setChangeColumnId(item.getChangeColumnId());//sourceId:69786_2_9422
                    oneItem.setArchivngType("TOBE_ARCHIVING");//sourceId:69789_2_9422
                    oneItem.setArchiveInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:69787_2_9422
                    oneItem.setArchiveTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:69788_2_9422

                    listChangeColumn_2.add(oneItem);
                }//sourceId:153439_1_9422

                /*1-1-02批量改底层变更字段状态为想存档[1630]   */

                bOOLEAN = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_2);


            }
        } else if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))) {
            //elseif(D1-1修订底层框架服务变更字段.主体生命周期 等于 当前有效)  9423

//ModelCode: reviseNotBatchContent
            BatchWriteBackBaseMainTableChangeColRespDto reviseNotBatchContentRes = null;
            BatchWriteBackBaseMainTableChangeColReqDto reviseNotBatchContentReq = new BatchWriteBackBaseMainTableChangeColReqDto();
            if (reqDto != null) {
                reviseNotBatchContentReq.setBaseMainTableChangeColList(reqDto.getChangeColumnList());//sourceId:286377_1_15305
            }

            /*M1批量回写底层框架主表变更字段（特殊方法）[3746]  入参：业务对象编码（表名）objectCode、对象属性编码（主键字段名）propertyCode、主键ID  uniqueId    对象属性+变更内容的数据集，更新任意一张表的数据 */

            reviseNotBatchContentRes = nbChangeColumn.batchWriteBackBaseMainTableChangeCol(reviseNotBatchContentReq);


            boolean bOOLEAN_1;
            if (listChangeColumn != null && listChangeColumn.size() > 0) {
                List<ChangeColumn> listChangeColumn_3 = new ArrayList<>();
                for (ChangeColumn item : listChangeColumn) {
                    ChangeColumn oneItem = new ChangeColumn();
                    oneItem.setChangeColumnId(item.getChangeColumnId());//sourceId:69790_2_9424
                    oneItem.setIsEditing("FALSE");//sourceId:69797_2_9424
                    oneItem.setIsArchive("TRUE");//sourceId:69798_2_9424
                    oneItem.setArchivngType("ARCHIVED");//sourceId:69794_2_9424
                    oneItem.setSubjectLifeCycle("ARCHIVING");//sourceId:69791_2_9424
                    oneItem.setArchiveInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:69792_2_9424
                    oneItem.setArchiveTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:69793_2_9424

                    listChangeColumn_3.add(oneItem);
                }//sourceId:153440_1_9424

                /*1-1-02批量改底层变更字段状态为历史存档[1630]   */

                bOOLEAN_1 = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_3);


            }
        }
//virtualUsage 1-1-02查内容ID本次已更新字段列表（正在编辑）  9398
        List<ChangeColumn> listChangeColumn_4 = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq_1 = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq_1.setSubjectUpdateStatus("REVISION");//sourceId:151656_1_9398
        queryBaseChangeColListReq_1.setIsInproperties("TRUE");//sourceId:23597_1_9398
        queryBaseChangeColListReq_1.setSubjectLifeCycle("EDITING");//sourceId:17175_1_9398
        queryBaseChangeColListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23614_1_9398
        if (reqDto != null) {
            queryBaseChangeColListReq_1.setBatchId(reqDto.getBatchId());//sourceId:181698_1_9398
            queryBaseChangeColListReq_1.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:17172_1_9398
            queryBaseChangeColListReq_1.setEntityId(reqDto.getEntityId());//sourceId:17173_1_9398
            queryBaseChangeColListReq_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//sourceId:151654_1_9398
            queryBaseChangeColListReq_1.setSubjectChangeType(reqDto.getSubjectChangeType());//sourceId:151655_1_9398
            queryBaseChangeColListReq_1.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:151652_1_9398
            queryBaseChangeColListReq_1.setObjectId(reqDto.getObjectId());//sourceId:151653_1_9398
        }

        /*1-1-02查内容ID本次已更新字段列表（正在编辑）[8]   */
        Assert.isNull(queryBaseChangeColListReq_1.getTableTypeCode(), "D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq_1.getEntityId(), "D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq_1.getSubjectTypeCode(), "D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq_1.getSubjectChangeType(), "D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体变更日志类型不能为空", false);
        Assert.isNull(queryBaseChangeColListReq_1.getSubjectUpdateStatus(), "D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体批次下更新状态不能为空", false);
        Assert.isNull(queryBaseChangeColListReq_1.getIsInproperties(), "D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq_1.getSubjectLifeCycle(), "D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq_1.getSpaceId(), "D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-创建于空间ID不能为空", false);
        listChangeColumn_4 = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq_1);


//virtualUsage 从更新字段中，分类出新增、修改字段（空方法）  9399
        //ModelCode: dataAuClassification
        FilterAddUpdateColumnRespDto dataAuClassificationRes = null;
        FilterAddUpdateColumnReqDto dataAuClassificationReq = new FilterAddUpdateColumnReqDto();
        dataAuClassificationReq.setBaseChangeColumnList(listChangeColumn_4.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.biz.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//sourceId:151662_1_9399
        if (reqDto != null) {
            dataAuClassificationReq.setChangeColumnList(reqDto.getChangeColumnList());//sourceId:47370_1_9399
        }

        /*从更新字段中，分类出新增、修改字段（空方法）[908]  入参两个数据集，出参两个数据集，分别对应：新增数据集、删除数据集 */

        dataAuClassificationRes = nbChangeColumn.filterAddUpdateColumn(dataAuClassificationReq);


//virtualUsage 1-1-02批量新增底层变更字段  9400
        boolean bOOLEAN_2;
        List<ChangeColumn> listChangeColumn_6 = new ArrayList<>();
        if (dataAuClassificationRes != null) {
            for (NewColumnDto item : dataAuClassificationRes.getNewColumnList()) {
                ChangeColumn oneItem = new ChangeColumn();
                oneItem.setSubjectUpdateStatus("REVISION");//sourceId:69337_2_9400
                oneItem.setIsInproperties("TRUE");//sourceId:69340_2_9400
                if (dataAuClassificationRes != null) {
                    oneItem.setObjectPropertyCode(item.getObjectPropertyCode());//sourceId:69330_2_9400
                    oneItem.setObjectPropertyName(item.getObjectPropertyName());//sourceId:69331_2_9400
                    oneItem.setMetaDataColumnContent(item.getMetaDataColumnContent());//sourceId:69332_2_9400
                    oneItem.setOriColumnContent(item.getOriColumnContent());//sourceId:69333_2_9400
                    oneItem.setColumnContent(item.getColumnContent());//sourceId:69334_2_9400
                }
                if (reqDto != null) {
                    oneItem.setSubjectTypeCode(reqDto.getSubjectTypeCode());//sourceId:69335_2_9400
                    oneItem.setSubjectChangeType(reqDto.getSubjectChangeType());//sourceId:69336_2_9400
                    oneItem.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:69338_2_9400
                    oneItem.setEntityName(reqDto.getEntityName());//sourceId:76957_2_9400
                    oneItem.setEntityId(reqDto.getEntityId());//sourceId:69339_2_9400
                    oneItem.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:69342_2_9400
                    oneItem.setObjectId(reqDto.getObjectId());//sourceId:69341_2_9400
                    oneItem.setBatchId(reqDto.getBatchId());//sourceId:76956_2_9400
                    oneItem.setBatchStartTime(reqDto.getBatchStartTime());//sourceId:69344_2_9400
                    oneItem.setBatchEndTime(reqDto.getBatchEndTime());//sourceId:69345_2_9400
                    oneItem.setIsEditing(reqDto.getIsEditing());//sourceId:69346_2_9400
                    oneItem.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:69347_2_9400
                }

                listChangeColumn_6.add(oneItem);
            }//sourceId:151587_1_9400
        }

        /*1-1-02批量新增底层变更字段[274]   */

        bOOLEAN_2 = mChangeColumnService.batchAddBaseChangeCol(listChangeColumn_6);


//virtualUsage 1-1-02批量改底层变更字段  9401
        boolean bOOLEAN_3;
        List<ChangeColumn> listChangeColumn_7 = new ArrayList<>();
        if (dataAuClassificationRes != null) {
            listChangeColumn_7 = dataAuClassificationRes.getModifyColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumn.class)).collect(Collectors.toList());//sourceId:151651_1_9401
        }

        /*1-1-02批量改底层变更字段[1630]   */

        bOOLEAN_3 = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_7);


//virtualUsage D1-1生成变更记录语义内容(公共)  15278
        GenerateChangeColSemanticContentComRespDto generateChangeColSemanticContentComRespDto = null;
        GenerateChangeColSemanticContentComReqDto generateChangeColSemanticContentComReqDto = new GenerateChangeColSemanticContentComReqDto();
        if (reqDto != null) {
            generateChangeColSemanticContentComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:285821_1_15278
            generateChangeColSemanticContentComReqDto.setEntityId(reqDto.getEntityId());//sourceId:285822_1_15278
            generateChangeColSemanticContentComReqDto.setReviseSubjectContent(reqDto.getReviseSubjectContent());//sourceId:287416_1_15278
        }

        /*D1-1生成变更记录语义内容(公共)[4331]   */
        Assert.isNull(generateChangeColSemanticContentComReqDto.getTableTypeCode(), "D1-1修订底层框架服务变更字段-D1-1生成变更记录语义内容(公共)-内容表类型编码不能为空", false);
        Assert.isNull(generateChangeColSemanticContentComReqDto.getEntityId(), "D1-1修订底层框架服务变更字段-D1-1生成变更记录语义内容(公共)-内容表主键ID不能为空", false);
        Assert.isNull(generateChangeColSemanticContentComReqDto.getReviseSubjectContent(), "D1-1修订底层框架服务变更字段-D1-1生成变更记录语义内容(公共)-修订主体内容不能为空", false);
        generateChangeColSemanticContentComRespDto = generateChangeColSemanticContentCom(generateChangeColSemanticContentComReqDto);


//processBranchName:正常结束 ,processBranchId:12564

        ReviseBaseChangeColRespDto retData = new ReviseBaseChangeColRespDto();


        return retData;
    }

    /**
     * D1-1查询底层框架服务变更字段列表[934]
     * gen by moon at 10/2/2022, 7:51:07 AM
     */
    @Trace(operationName = "D1-1查询底层框架服务变更字段列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryBaseChangeColListRespDto queryBaseChangeColList(QueryBaseChangeColListReqDto reqDto) {


        List<ChangeColumn> listChangeColumn_1 = new ArrayList<>();
//步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:18304_1
        queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:18308_1
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23616_1
        queryBaseChangeColListReq.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23617_1
        if (reqDto != null) {
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:18293_1
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:18294_1
        }

        /*1-1-02查询底层变更字段列表[8]   */
        Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(), "D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getEntityId(), "D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getIsInproperties(), "D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-创建于空间ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getAppId(), "D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-创建于联盟应用ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


        listChangeColumn_1 = listChangeColumn;

        QueryBaseChangeColListRespDto retData = new QueryBaseChangeColListRespDto();
        retData.setBaseChangeColumnList(listChangeColumn_1.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.base.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:18312_1


        return retData;
    }

    /**
     * D1-1查询底层变更记录列表[3494]
     * gen by moon at 10/2/2022, 3:28:37 AM
     */
    @Trace(operationName = "D1-1查询底层变更记录列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryBaseChangeRecordListRespDto queryBaseChangeRecordList(QueryBaseChangeRecordListReqDto reqDto) {


        List<ChangeColumn> listChangeColumn_1 = new ArrayList<>();
//步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:148707_1
        if (reqDto != null) {
            queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:148497_1
            queryBaseChangeColListReq.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:148892_1
            queryBaseChangeColListReq.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:148709_1
            queryBaseChangeColListReq.setSubjectUpdateStatus(reqDto.getSubjectUpdateStatus());//SimpleFieldAssign//sourceId:148893_1
            queryBaseChangeColListReq.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:148890_1
            queryBaseChangeColListReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:148891_1
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:148888_1
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:148889_1
        }

        /*1-1-02查询底层变更字段列表[8]   */
        Assert.isNull(queryBaseChangeColListReq.getSubjectTypeCode(), "D1-1查询底层变更记录列表-1-1-02查询底层变更字段列表-主体类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-1查询底层变更记录列表-1-1-02查询底层变更字段列表-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


        listChangeColumn_1 = listChangeColumn;

        QueryBaseChangeRecordListRespDto retData = new QueryBaseChangeRecordListRespDto();
        retData.setBaseChangeColumnList(listChangeColumn_1.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.base.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:148714_1


        return retData;
    }

    /**
     * D1-1新增底层变更字段(公共)[3533]
     * gen by moon at 8/24/2023, 1:19:26 PM
     */
    @Trace(operationName = "D1-1新增底层变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddBaseChangeColComRespDto addBaseChangeColCom(AddBaseChangeColComReqDto reqDto) {


        //步骤0: M1-自动生成语义内容（特殊方法） - autoAenerateSemanticContent
        //ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes = null;
        AutoAenerateSemanticContentReqDto generateSemanticInstanceReq = new AutoAenerateSemanticContentReqDto();
        if (reqDto != null) {
            generateSemanticInstanceReq.setAddBehaviorName(reqDto.getObjectPropertyName());//SimpleFieldAssign//sourceId:287382_1
            generateSemanticInstanceReq.setAddSubjectContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:287385_1
            generateSemanticInstanceReq.setSubjectContAffiliationParentCont(reqDto.getSubjectContAffiliationParentCont());//SimpleFieldAssign//sourceId:287383_1
        }

        /*M1-本次新增变更字段语义故事[3975]  解析语义模板，生成模板实例 */
        Assert.isNull(generateSemanticInstanceReq.getAddBehaviorName(), "D1-1新增底层变更字段(公共)-M1-本次新增变更字段语义故事-新增行为名称不能为空", false);
        Assert.isNull(generateSemanticInstanceReq.getAddSubjectContent(), "D1-1新增底层变更字段(公共)-M1-本次新增变更字段语义故事-新增主体内容不能为空", false);
        generateSemanticInstanceRes = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq);


//步骤1: 1-1-02新增底层框架服务变更字段 - addBaseChangeColumn
        String string = null;
        ChangeColumn changeColumn = new ChangeColumn();
        changeColumn.setIsInproperties("FALSE");//sourceId:154344_1
        changeColumn.setSubjectUpdateStatus("NEW");//sourceId:154394_1
        if (reqDto != null) {
            changeColumn.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:154341_1
            changeColumn.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:162131_1
            changeColumn.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:154342_1
            changeColumn.setObjectPropertyCode(reqDto.getObjectPropertyCode());//SimpleFieldAssign//sourceId:154339_1
            changeColumn.setMetaDataColumnContent(reqDto.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:154340_1
            changeColumn.setColumnContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:154389_1
            changeColumn.setOriColumnContent(reqDto.getOriColumnContent());//SimpleFieldAssign//sourceId:154390_1
            changeColumn.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:154391_1
            changeColumn.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:154345_1
            changeColumn.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:154392_1
            changeColumn.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:154393_1
            changeColumn.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:154395_1
            changeColumn.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:154396_1
            changeColumn.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:154397_1
            changeColumn.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:154398_1
            changeColumn.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:154405_1
        }
        if (generateSemanticInstanceRes != null) {
            changeColumn.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:154388_1
        }

        /*1-1-02新增底层框架服务变更字段[5]   */
        Assert.isNull(changeColumn.getTableTypeCode(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空", false);
        Assert.isNull(changeColumn.getEntityName(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空", false);
        Assert.isNull(changeColumn.getEntityId(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空", false);
        Assert.isNull(changeColumn.getObjectPropertyCode(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空", false);
        Assert.isNull(changeColumn.getObjectPropertyName(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空", false);
        Assert.isNull(changeColumn.getMetaDataColumnContent(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段原始值不能为空", false);
        Assert.isNull(changeColumn.getColumnContent(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更后字段中文内容不能为空", false);
        Assert.isNull(changeColumn.getOriColumnContent(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更前字段中文内容不能为空", false);
        Assert.isNull(changeColumn.getIsInproperties(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空", false);
        Assert.isNull(changeColumn.getSubjectUpdateStatus(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空", false);
        Assert.isNull(changeColumn.getIsEditing(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空", false);
        Assert.isNull(changeColumn.getSubjectLifeCycle(), "D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空", false);
        string = mChangeColumnService.addBaseChangeColumn(changeColumn)/*vcase invoke 本地 method 方法调用;*/;


        AddBaseChangeColComRespDto retData = new AddBaseChangeColComRespDto();


        return retData;
    }

    /**
     * D1-1存档底层变更字段(公共)[3535]
     * gen by moon at 9/20/2023, 11:29:53 PM
     */
    @Trace(operationName = "D1-1存档底层变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ArchiveBaseChangeColComRespDto archiveBaseChangeColCom(ArchiveBaseChangeColComReqDto reqDto) {


        //virtualUsage M1-构造存档日志故事  15330
        //ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes = null;
        AutoAenerateSemanticContentReqDto generateSemanticInstanceReq = new AutoAenerateSemanticContentReqDto();
        if (reqDto != null) {
            generateSemanticInstanceReq.setArchiveBehaviorName(reqDto.getObjectPropertyName());//SimpleFieldAssign//sourceId:287369_1_15330
            generateSemanticInstanceReq.setArchiveSubjectContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:287366_1_15330
            generateSemanticInstanceReq.setSubjectContAffiliationParentCont(reqDto.getSubjectContAffiliationParentCont());//SimpleFieldAssign//sourceId:287368_1_15330
        }

        /*M1-构造存档日志故事[3975]  解析语义模板，生成模板实例 */
        Assert.isNull(generateSemanticInstanceReq.getArchiveBehaviorName(), "D1-1存档底层变更字段(公共)-M1-构造存档日志故事-存档行为名称不能为空", false);
        Assert.isNull(generateSemanticInstanceReq.getArchiveSubjectContent(), "D1-1存档底层变更字段(公共)-M1-构造存档日志故事-存档主体内容不能为空", false);
        generateSemanticInstanceRes = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq);


        if ((reqDto != null && reqDto.getBatchId() != null)) {
            //if(D1-1存档底层变更字段(公共).批次ID 值不等于空 )  9465

            String string = null;
            ChangeColumn changeColumn = new ChangeColumn();
            changeColumn.setIsInproperties("FALSE");//sourceId:181393_1_11775
            changeColumn.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:181401_1_11775
            changeColumn.setSubjectUpdateStatus("ARCHIVE");//sourceId:181398_1_11775
            changeColumn.setIsEditing("TRUE");//sourceId:181402_1_11775
            changeColumn.setSubjectLifeCycle("EDITING");//sourceId:181403_1_11775
            if (reqDto != null) {
                changeColumn.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:181385_1_11775
                changeColumn.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:181386_1_11775
                changeColumn.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:181387_1_11775
                changeColumn.setObjectPropertyCode(reqDto.getObjectPropertyCode());//SimpleFieldAssign//sourceId:181388_1_11775
                changeColumn.setMetaDataColumnContent(reqDto.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:181390_1_11775
                changeColumn.setColumnContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:181391_1_11775
                changeColumn.setOriColumnContent(reqDto.getOriColumnContent());//SimpleFieldAssign//sourceId:181392_1_11775
                changeColumn.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:181394_1_11775
                changeColumn.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:181395_1_11775
                changeColumn.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:181396_1_11775
                changeColumn.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:181397_1_11775
                changeColumn.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:181399_1_11775
            }
            if (generateSemanticInstanceRes != null) {
                changeColumn.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:181389_1_11775
            }

            /*1-1-02新增底层变更字段（用于想存档日志）[5]   */
            Assert.isNull(changeColumn.getTableTypeCode(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-内容表类型编码不能为空", false);
            Assert.isNull(changeColumn.getEntityName(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-内容表主键行为日志英文名称不能为空", false);
            Assert.isNull(changeColumn.getEntityId(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-内容表主键ID不能为空", false);
            Assert.isNull(changeColumn.getObjectPropertyCode(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更字段英文名不能为空", false);
            Assert.isNull(changeColumn.getObjectPropertyName(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更字段行为日志名称不能为空", false);
            Assert.isNull(changeColumn.getMetaDataColumnContent(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更字段原始值不能为空", false);
            Assert.isNull(changeColumn.getColumnContent(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更后字段中文内容不能为空", false);
            Assert.isNull(changeColumn.getOriColumnContent(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更前字段中文内容不能为空", false);
            Assert.isNull(changeColumn.getIsInproperties(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-是否内部属性不能为空", false);
            Assert.isNull(changeColumn.getSubjectTypeCode(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-主体类型编码不能为空", false);
            Assert.isNull(changeColumn.getSubjectChangeType(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-主体变更日志类型不能为空", false);
            Assert.isNull(changeColumn.getObjectTypeCode(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-归属对象类型编码不能为空", false);
            Assert.isNull(changeColumn.getObjectId(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-归属对象内容ID不能为空", false);
            Assert.isNull(changeColumn.getBatchEndTime(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-批次结束时间不能为空", false);
            Assert.isNull(changeColumn.getSubjectUpdateStatus(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-主体批次下更新状态不能为空", false);
            Assert.isNull(changeColumn.getIsEditing(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-是否未来不能为空", false);
            Assert.isNull(changeColumn.getSubjectLifeCycle(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-主体生命周期不能为空", false);
            string = mChangeColumnService.addBaseChangeColumn(changeColumn)/*vcase invoke 本地 method 方法调用;*/;


//processBranchName:正常结束 ,processBranchId:9471

        } else if ((reqDto != null && reqDto.getBatchId() == null)) {
            //elseif(D1-1存档底层变更字段(公共).批次ID 值等于空 )  11781

            String string_2 = null;
            ChangeColumn changeColumn_1 = new ChangeColumn();
            changeColumn_1.setIsInproperties("TRUE");//sourceId:181518_1_11782
            changeColumn_1.setSubjectUpdateStatus("ARCHIVE");//sourceId:181525_1_11782
            changeColumn_1.setIsEditing("FALSE");//sourceId:285502_1_11782
            changeColumn_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:181517_1_11782
            if (reqDto != null) {
                changeColumn_1.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:181513_1_11782
                changeColumn_1.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:181530_1_11782
                changeColumn_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:181514_1_11782
                changeColumn_1.setObjectPropertyCode(reqDto.getObjectPropertyCode());//SimpleFieldAssign//sourceId:181511_1_11782
                changeColumn_1.setMetaDataColumnContent(reqDto.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:181512_1_11782
                changeColumn_1.setColumnContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:181523_1_11782
                changeColumn_1.setOriColumnContent(reqDto.getOriColumnContent());//SimpleFieldAssign//sourceId:181522_1_11782
                changeColumn_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:181524_1_11782
                changeColumn_1.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:181519_1_11782
                changeColumn_1.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:181527_1_11782
                changeColumn_1.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:181526_1_11782
            }
            if (generateSemanticInstanceRes != null) {
                changeColumn_1.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:181521_1_11782
            }

            /*1-1-02新增底层变更字段（非批次直接存档）[5]   */
            Assert.isNull(changeColumn_1.getTableTypeCode(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-内容表类型编码不能为空", false);
            Assert.isNull(changeColumn_1.getEntityName(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-内容表主键行为日志英文名称不能为空", false);
            Assert.isNull(changeColumn_1.getEntityId(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-内容表主键ID不能为空", false);
            Assert.isNull(changeColumn_1.getObjectPropertyCode(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更字段英文名不能为空", false);
            Assert.isNull(changeColumn_1.getObjectPropertyName(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更字段行为日志名称不能为空", false);
            Assert.isNull(changeColumn_1.getMetaDataColumnContent(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更字段原始值不能为空", false);
            Assert.isNull(changeColumn_1.getColumnContent(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更后字段中文内容不能为空", false);
            Assert.isNull(changeColumn_1.getOriColumnContent(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更前字段中文内容不能为空", false);
            Assert.isNull(changeColumn_1.getIsInproperties(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-是否内部属性不能为空", false);
            Assert.isNull(changeColumn_1.getSubjectTypeCode(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-主体类型编码不能为空", false);
            Assert.isNull(changeColumn_1.getSubjectChangeType(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-主体变更日志类型不能为空", false);
            Assert.isNull(changeColumn_1.getObjectTypeCode(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-归属对象类型编码不能为空", false);
            Assert.isNull(changeColumn_1.getObjectId(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-归属对象内容ID不能为空", false);
            Assert.isNull(changeColumn_1.getSubjectUpdateStatus(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-主体批次下更新状态不能为空", false);
            Assert.isNull(changeColumn_1.getIsEditing(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-是否未来不能为空", false);
            Assert.isNull(changeColumn_1.getSubjectLifeCycle(), "D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-主体生命周期不能为空", false);
            string_2 = mChangeColumnService.addBaseChangeColumn(changeColumn_1)/*vcase invoke 本地 method 方法调用;*/;


//processBranchName:正常结束 ,processBranchId:11783

        }
        ArchiveBaseChangeColComRespDto retData = new ArchiveBaseChangeColComRespDto();


        return retData;
    }

    /**
     * D1-1批量删底层变更字段(公共)[3540]
     * gen by moon at 9/20/2023, 11:32:33 PM
     */
    @Trace(operationName = "D1-1批量删底层变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchDeleteBaseChangeColComRespDto batchDeleteBaseChangeColCom(BatchDeleteBaseChangeColComReqDto reqDto) {


        //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:155172_1
        if (reqDto != null) {
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:155169_1
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:155170_1
        }

        /*1-1-02查询底层变更字段列表[8]   */
        Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(), "D1-1批量删底层变更字段(公共)-1-1-02查询底层变更字段列表-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getEntityId(), "D1-1批量删底层变更字段(公共)-1-1-02查询底层变更字段列表-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-1批量删底层变更字段(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 1-1-02批量删除底层框架服务变更字段 - batchDeleteBaseChangeColumn
        boolean bOOLEAN;
        if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn.size() > 0) {
            List<String> listString = new ArrayList<>();
            if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn)) {
                listString = listChangeColumn.stream().map(item -> item.getChangeColumnId())
                        .collect(Collectors.toList());/*list-to-strings*///sourceId:155183_1
            }

            /*1-1-02批量删除底层框架服务变更字段[7]   */

            bOOLEAN = mChangeColumnService.batchDeleteBaseChangeColumn(listString)/*vcase invoke 本地 method 方法调用;*/;


        }

        BatchDeleteBaseChangeColComRespDto retData = new BatchDeleteBaseChangeColComRespDto();


        return retData;
    }

    /**
     * D1-1撤销修订组织架构批次处理变更字段(公共)[3743]
     * gen by moon at 10/1/2022, 11:48:17 PM
     */
    @Trace(operationName = "D1-1撤销修订组织架构批次处理变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UndoReviseOrgBatchHandleChangeColComRespDto undoReviseOrgBatchHandleChangeColCom(UndoReviseOrgBatchHandleChangeColComReqDto reqDto) {


        //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:320737_1
        if (reqDto != null) {
            queryBaseChangeColListReq.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:176391_1
            queryBaseChangeColListReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:176392_1
            queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176305_1
        }

        /*1-1-02查正在编辑底层框架变更字段[8]   */
        Assert.isNull(queryBaseChangeColListReq.getObjectTypeCode(), "D1-1撤销修订组织架构批次处理变更字段(公共)-1-1-02查正在编辑底层框架变更字段-归属对象类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getObjectId(), "D1-1撤销修订组织架构批次处理变更字段(公共)-1-1-02查正在编辑底层框架变更字段-归属对象内容ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getBatchId(), "D1-1撤销修订组织架构批次处理变更字段(公共)-1-1-02查正在编辑底层框架变更字段-批次ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1-1撤销修订组织架构批次处理变更字段(公共)-1-1-02查正在编辑底层框架变更字段-主体生命周期不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


//步骤1: 1-1-02批量删除底层框架服务变更字段 - batchDeleteBaseChangeColumn
        boolean bOOLEAN;
        if (listChangeColumn != null && listChangeColumn.size() > 0) {
            List<String> listString = new ArrayList<>();
            listString = listChangeColumn.stream().map(item -> item.getChangeColumnId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:176194_1

            /*1-1-02批量删除底层框架服务变更字段[7]   */

            bOOLEAN = mChangeColumnService.batchDeleteBaseChangeColumn(listString);


        }

        UndoReviseOrgBatchHandleChangeColComRespDto retData = new UndoReviseOrgBatchHandleChangeColComRespDto();


        return retData;
    }

    /**
     * D1-1更新批次处理组织架构变更字段(公共)[3742]
     * gen by moon at 9/20/2023, 11:29:24 PM
     */
    @Trace(operationName = "D1-1更新批次处理组织架构变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public RefreshBatchProcessingOrgChangeColComRespDto refreshBatchProcessingOrgChangeColCom(RefreshBatchProcessingOrgChangeColComReqDto reqDto) {


        //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:284969_1
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:284970_1
        if (reqDto != null) {
            queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:284968_1
            queryBaseChangeColListReq.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:284966_1
            queryBaseChangeColListReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:284967_1
        }

        /*1-1-02查询正在编辑底层变更字段列表（用于发布生效）[8]   */
        Assert.isNull(queryBaseChangeColListReq.getBatchId(), "D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-批次ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getObjectTypeCode(), "D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-归属对象类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getObjectId(), "D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-归属对象内容ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 1-1-02批量改底层变更字段 - batchUpdateBaseChangeCol
        boolean bOOLEAN;
        if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn.size() > 0) {
            List<ChangeColumn> listChangeColumn_2 = new ArrayList<>();
            if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn)) {
                listChangeColumn_2 = listChangeColumn.stream().map(item -> {
                    ChangeColumn elm = BeanUtil.toBean(item, ChangeColumn.class);
                    elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME
                    elm.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME
                    elm.setIsEditing("FALSE");
                    elm.setIsArchive("FALSE");
                    elm.setArchivngType("NOT_ARCHIVE");
                    elm.setSubjectLifeCycle("CURRENTLY_VALID");
                    elm.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID
                    elm.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:176142_1
            }

            /*1-1-02批量改底层框架变更字段为当前有效[1630]   */

            bOOLEAN = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_2)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤2: D1批量回写底层变更字段(公共) - batchWriteBackBaseChangeColCom
        BatchWriteBackBaseChangeColComRespDto batchWriteBackBaseChangeColComRespDto = null;
        BatchWriteBackBaseChangeColComReqDto batchWriteBackBaseChangeColComReqDto = new BatchWriteBackBaseChangeColComReqDto();
        batchWriteBackBaseChangeColComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:306218_1
        if (reqDto != null) {
            batchWriteBackBaseChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:306213_1
            batchWriteBackBaseChangeColComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:306216_1
            batchWriteBackBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:306217_1
        }

        /*D1批量回写底层变更字段(公共)[4382]   */
        Assert.isNull(batchWriteBackBaseChangeColComReqDto.getBatchId(), "D1-1更新批次处理组织架构变更字段(公共)-D1批量回写底层变更字段(公共)-批次ID不能为空", false);
        Assert.isNull(batchWriteBackBaseChangeColComReqDto.getObjectTypeCode(), "D1-1更新批次处理组织架构变更字段(公共)-D1批量回写底层变更字段(公共)-归属对象类型编码不能为空", false);
        Assert.isNull(batchWriteBackBaseChangeColComReqDto.getObjectId(), "D1-1更新批次处理组织架构变更字段(公共)-D1批量回写底层变更字段(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(batchWriteBackBaseChangeColComReqDto.getSubjectLifeCycle(), "D1-1更新批次处理组织架构变更字段(公共)-D1批量回写底层变更字段(公共)-主体生命周期不能为空", false);
        batchWriteBackBaseChangeColComRespDto = batchWriteBackBaseChangeColCom(batchWriteBackBaseChangeColComReqDto)/*vcase invoke 同服务,同domain*/;


        RefreshBatchProcessingOrgChangeColComRespDto retData = new RefreshBatchProcessingOrgChangeColComRespDto();


        return retData;
    }

    /**
     * D1修订底层变更字段(公共)[3921]
     * gen by moon at 9/13/2022, 3:33:33 AM
     */
    @Trace(operationName = "D1修订底层变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @BanAuto
    @Override
    public ReviseBaseChangeColComRespDto reviseBaseChangeColCom(ReviseBaseChangeColComReqDto reqDto) {


        ImplementBaseContentDetailsMergeFieldsRespDto mergeChangeColumnDetailRes_1 = null;
//virtualUsage 1-1-02查询底层变更字段列表  15913
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:197733_1_15913
        queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:197714_1_15913
        queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:197710_1_15913
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:197707_1_15913
        if (reqDto != null) {
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:197704_1_15913
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//sourceId:197705_1_15913
        }

        /*1-1-02查询底层变更字段列表[8]   */
        Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(), "D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getEntityId(), "D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getIsInproperties(), "D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(), "D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


        if ((listChangeColumn != null && listChangeColumn != null && listChangeColumn.size() >= 0)) {
            //if(1-1-02查询底层变更字段列表.底层框架服务变更字段列表数据集条数 大于等于 0)  15914

//ModelCode: mergeChangeColumnDetail
            ImplementBaseContentDetailsMergeFieldsRespDto mergeChangeColumnDetailRes = null;
//    if(listChangeColumn !=null&& listChangeColumn.size()>0 ){
            ImplementBaseContentDetailsMergeFieldsReqDto mergeChangeColumnDetailReq = new ImplementBaseContentDetailsMergeFieldsReqDto();
            mergeChangeColumnDetailReq.setBaseChangeColList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, BaseChangeColDto.class)).collect(Collectors.toList()));//sourceId:197607_1_15915
            if (reqDto != null) {
                mergeChangeColumnDetailReq.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//sourceId:197609_1_15915
                mergeChangeColumnDetailReq.setPositionGradeId(reqDto.getPositionGradeId());//sourceId:200800_1_15915
                mergeChangeColumnDetailReq.setStationId(reqDto.getStationId());//sourceId:200801_1_15915
                mergeChangeColumnDetailReq.setTypeDictionaryId(reqDto.getTypeDictionaryId());//sourceId:200802_1_15915
                mergeChangeColumnDetailReq.setPositionDutyDesc(reqDto.getPositionDutyDesc());//sourceId:200803_1_15915
                mergeChangeColumnDetailReq.setPositionTargetDesc(reqDto.getPositionTargetDesc());//sourceId:200804_1_15915
                mergeChangeColumnDetailReq.setRoleMemberId(reqDto.getRoleMemberId());//sourceId:308023_1_15915
//mergeChangeColumnDetailReq.setDirectorInductionId(reqDto.getDirectorInductionId());//sourceId:308024_1_15915
                mergeChangeColumnDetailReq.setDeptNumber(reqDto.getDeptNumber());//sourceId:308025_1_15915
                mergeChangeColumnDetailReq.setDeptName(reqDto.getDeptName());//sourceId:308026_1_15915
                mergeChangeColumnDetailReq.setDeptEnName(reqDto.getDeptEnName());//sourceId:308027_1_15915
                mergeChangeColumnDetailReq.setDeptShortName(reqDto.getDeptShortName());//sourceId:308028_1_15915
                mergeChangeColumnDetailReq.setDeptDutyDesc(reqDto.getDeptDutyDesc());//sourceId:308029_1_15915
                mergeChangeColumnDetailReq.setDeptTargetDesc(reqDto.getDeptTargetDesc());//sourceId:308030_1_15915
            }

            /*M1执行底层内容详情合并字段（特殊方法）[3534]  通过合并标识，将第二个数据集的数据覆盖第一个入参的数据 */

            mergeChangeColumnDetailRes = nbChangeColumn.implementBaseContentDetailsMergeFields(mergeChangeColumnDetailReq);


            mergeChangeColumnDetailRes_1 = mergeChangeColumnDetailRes;
        }
//processBranchName:正常结束 ,processBranchId:15916

//      }
        ReviseBaseChangeColComRespDto retData = new ReviseBaseChangeColComRespDto();
        if (mergeChangeColumnDetailRes_1 != null) {
            retData.setDirectorInductionRecordId(mergeChangeColumnDetailRes_1.getDirectorInductionRecordId());//sourceId:197667_1
            retData.setPositionGradeId(mergeChangeColumnDetailRes_1.getPositionGradeId());//sourceId:200845_1
            retData.setStationId(mergeChangeColumnDetailRes_1.getStationId());//sourceId:200846_1
            retData.setTypeDictionaryId(mergeChangeColumnDetailRes_1.getTypeDictionaryId());//sourceId:200847_1
            retData.setPositionDutyDesc(mergeChangeColumnDetailRes_1.getPositionDutyDesc());//sourceId:200848_1
            retData.setPositionTargetDesc(mergeChangeColumnDetailRes_1.getPositionTargetDesc());//sourceId:200849_1
            retData.setRoleMemberId(mergeChangeColumnDetailRes_1.getRoleMemberId());//sourceId:308047_1
//retData.setDirectorInductionId(mergeChangeColumnDetailRes_1.getDirectorInductionId());//sourceId:308048_1
            retData.setDeptNumber(mergeChangeColumnDetailRes_1.getDeptNumber());//sourceId:308049_1
            retData.setDeptName(mergeChangeColumnDetailRes_1.getDeptName());//sourceId:308050_1
            retData.setDeptEnName(mergeChangeColumnDetailRes_1.getDeptEnName());//sourceId:308051_1
            retData.setDeptShortName(mergeChangeColumnDetailRes_1.getDeptShortName());//sourceId:308052_1
            retData.setDeptDutyDesc(mergeChangeColumnDetailRes_1.getDeptDutyDesc());//sourceId:308053_1
            retData.setDeptTargetDesc(mergeChangeColumnDetailRes_1.getDeptTargetDesc());//sourceId:308054_1
        }


        return retData;
    }

    /**
     * D1-1撤销存档底层变更字段(公共)[3802]
     * gen by moon at 10/1/2022, 11:53:03 PM
     */
    @Trace(operationName = "D1-1撤销存档底层变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UndoArchiveBaseChangeColComRespDto undoArchiveBaseChangeColCom(UndoArchiveBaseChangeColComReqDto reqDto) {


        //步骤0: 1-1-02查询底层变更字段详情 - queryBaseChangeColDetail
        ChangeColumn changeColumn = null;
        QueryBaseChangeColDetailReq queryBaseChangeColDetailReq = new QueryBaseChangeColDetailReq();
        queryBaseChangeColDetailReq.setIsInproperties("FALSE");//sourceId:181630_1
        queryBaseChangeColDetailReq.setSubjectUpdateStatus("ARCHIVE");//sourceId:181634_1
        queryBaseChangeColDetailReq.setSubjectLifeCycle("EDITING");//sourceId:181631_1
        if (reqDto != null) {
            queryBaseChangeColDetailReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:181628_1
            queryBaseChangeColDetailReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:181629_1
        }

        /*1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）[3536]   */
        Assert.isNull(queryBaseChangeColDetailReq.getTableTypeCode(), "D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColDetailReq.getEntityId(), "D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColDetailReq.getIsInproperties(), "D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColDetailReq.getSubjectUpdateStatus(), "D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-主体批次下更新状态不能为空", false);
        Assert.isNull(queryBaseChangeColDetailReq.getSubjectLifeCycle(), "D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-主体生命周期不能为空", false);
        changeColumn = mChangeColumnService.queryBaseChangeColDetail(queryBaseChangeColDetailReq);


//步骤1: 1-1-02删除底层框架服务变更字段 - deleteBaseChangeColumn
        boolean bOOLEAN;
        if (changeColumn != null) {
            String string = new String();
            if (changeColumn != null) {
                string = changeColumn.getChangeColumnId();
                ;//SimpleFieldAssign//sourceId:181635_1
            }

            /*1-1-02删除底层变更字段（用于主表主键存档撤销）[917]   */
            Assert.isNull(string, "D1-1撤销存档底层变更字段(公共)-1-1-02删除底层变更字段（用于主表主键存档撤销）-变更字段记录ID不能为空", false);
            bOOLEAN = mChangeColumnService.deleteBaseChangeColumn(string);


        }

        UndoArchiveBaseChangeColComRespDto retData = new UndoArchiveBaseChangeColComRespDto();


        return retData;
    }

    /**
     * D1-1生成变更记录语义内容(公共)[4331]
     * gen by moon at 9/3/2022, 5:59:55 PM
     */
    @Trace(operationName = "D1-1生成变更记录语义内容(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public GenerateChangeColSemanticContentComRespDto generateChangeColSemanticContentCom(GenerateChangeColSemanticContentComReqDto reqDto) {


        //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:285804_1
        queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:285704_1
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:285697_1
        if (reqDto != null) {
            queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//sourceId:302241_1
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:285694_1
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//sourceId:285695_1
            queryBaseChangeColListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:287643_1
        }

        /*1-1-02查询底层变更字段列表[8]   */
        Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(), "D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getEntityId(), "D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getIsInproperties(), "D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(), "D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


//步骤1: M1-1-02执行变更字段【循环开始】 - implementChangeColLoopStart
        //ModelCode: circulationCollections
        for (ChangeColumn circulationCollectionsRes : listChangeColumn) {


//步骤2: M1-自动生成语义内容（特殊方法） - autoAenerateSemanticContent
            //ModelCode: generateSemanticInstance
            AutoAenerateSemanticContentRespDto generateSemanticInstanceRes = null;
            AutoAenerateSemanticContentReqDto generateSemanticInstanceReq = new AutoAenerateSemanticContentReqDto();
            if (reqDto != null) {
                generateSemanticInstanceReq.setReviseSubjectContent(reqDto.getReviseSubjectContent());//sourceId:287411_1
            }
            if (circulationCollectionsRes != null) {
                generateSemanticInstanceReq.setReviseBehaviorName(circulationCollectionsRes.getObjectPropertyName());//sourceId:287412_1
                generateSemanticInstanceReq.setColumnContent(circulationCollectionsRes.getColumnContent());//sourceId:287414_1
            }

            /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
            Assert.isNull(generateSemanticInstanceReq.getReviseSubjectContent(), "D1-1生成变更记录语义内容(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空", false);
            Assert.isNull(generateSemanticInstanceReq.getReviseBehaviorName(), "D1-1生成变更记录语义内容(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空", false);
            Assert.isNull(generateSemanticInstanceReq.getColumnContent(), "D1-1生成变更记录语义内容(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空", false);
            generateSemanticInstanceRes = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq);


//步骤3: 1-1-02修改底层变更字段 - updateBaseChangeCol
            boolean bOOLEAN;
            ChangeColumn changeColumn = new ChangeColumn();
            if (circulationCollectionsRes != null) {
                changeColumn.setChangeColumnId(circulationCollectionsRes.getChangeColumnId());//sourceId:285816_1
            }
            if (generateSemanticInstanceRes != null) {
                changeColumn.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//sourceId:285818_1
            }

            /*1-1-02修改底层变更字段（回写变更字段行为日志名称）[6]   */
            Assert.isNull(changeColumn.getChangeColumnId(), "D1-1生成变更记录语义内容(公共)-1-1-02修改底层变更字段（回写变更字段行为日志名称）-变更字段记录ID不能为空", false);
            Assert.isNull(changeColumn.getObjectPropertyName(), "D1-1生成变更记录语义内容(公共)-1-1-02修改底层变更字段（回写变更字段行为日志名称）-变更字段行为日志名称不能为空", false);
            bOOLEAN = mChangeColumnService.updateBaseChangeCol(changeColumn);


//步骤4: M-循环结束（特殊方法） - addCycleCreate
            //ModelCode: circulationEnd
        }


        GenerateChangeColSemanticContentComRespDto retData = new GenerateChangeColSemanticContentComRespDto();


        return retData;
    }

    /**
     * D1-1修改底层变更字段(公共)[4335]
     * gen by moon at 1/24/2024, 7:08:44 PM
     */
    @Trace(operationName = "D1-1修改底层变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateBaseChangeColComRespDto updateBaseChangeColCom(UpdateBaseChangeColComReqDto reqDto) {


        //步骤0: 1-1-02查询底层变更字段详情 - queryBaseChangeColDetail
        ChangeColumn changeColumn = null;
        QueryBaseChangeColDetailReq queryBaseChangeColDetailReq = new QueryBaseChangeColDetailReq();
        queryBaseChangeColDetailReq.setIsInproperties("FALSE");//sourceId:286516_1
        queryBaseChangeColDetailReq.setSubjectUpdateStatus("NEW");//sourceId:286520_1
        queryBaseChangeColDetailReq.setSubjectLifeCycle("EDITING");//sourceId:286517_1
        if (reqDto != null) {
            queryBaseChangeColDetailReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:286514_1
            queryBaseChangeColDetailReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:286515_1
        }

        /*1-1-02查询底层变更字段（主体内容本次新增的变更字段）[3536]   */
        Assert.isNull(queryBaseChangeColDetailReq.getTableTypeCode(), "D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColDetailReq.getEntityId(), "D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColDetailReq.getIsInproperties(), "D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColDetailReq.getSubjectUpdateStatus(), "D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-主体批次下更新状态不能为空", false);
        Assert.isNull(queryBaseChangeColDetailReq.getSubjectLifeCycle(), "D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-主体生命周期不能为空", false);
        changeColumn = mChangeColumnService.queryBaseChangeColDetail(queryBaseChangeColDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 1-1-02修改底层变更字段 - updateBaseChangeCol
        boolean bOOLEAN;
        if (changeColumn != null) {
            ChangeColumn changeColumn_2 = new ChangeColumn();
            if (changeColumn != null) {
                changeColumn_2.setChangeColumnId(changeColumn.getChangeColumnId());//SimpleFieldAssign//sourceId:286534_1
                changeColumn_2.setOriColumnContent(changeColumn.getColumnContent());//SimpleFieldAssign//sourceId:286538_1
            }
            if (reqDto != null) {
                changeColumn_2.setColumnContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:286539_1
            }

            /*1-1-02修改底层变更字段[6]   */
            Assert.isNull(changeColumn_2.getChangeColumnId(), "D1-1修改底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空", false);
            Assert.isNull(changeColumn_2.getOriColumnContent(), "D1-1修改底层变更字段(公共)-1-1-02修改底层变更字段-变更前字段中文内容不能为空", false);
            Assert.isNull(changeColumn_2.getColumnContent(), "D1-1修改底层变更字段(公共)-1-1-02修改底层变更字段-变更后字段中文内容不能为空", false);
            bOOLEAN = mChangeColumnService.updateBaseChangeCol(changeColumn_2)/*vcase invoke 本地 method 方法调用;*/;


        }

        UpdateBaseChangeColComRespDto retData = new UpdateBaseChangeColComRespDto();


        return retData;
    }

    /**
     * D1-判断重置修订元素(公共)[4343]
     * gen by moon at 9/2/2022, 2:58:12 PM
     */
    @Trace(operationName = "D1-判断重置修订元素(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeResetReviseElementComRespDto judgeResetReviseElementCom(JudgeResetReviseElementComReqDto reqDto) {


        Long unknown_1 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_1 = null;
//virtualUsage 1-1-02查询底层变更字段列表  15374
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:287679_1_15374
        queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:287680_1_15374
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:287681_1_15374

        /*1-1-02查询底层变更字段列表[8]   */
        Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(), "D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getEntityId(), "D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getIsInproperties(), "D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(), "D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


        if ((listChangeColumn != null && listChangeColumn != null && listChangeColumn.size() > 0)) {
            //if(1-1-02查询底层变更字段列表.底层框架服务变更字段列表数据集条数 大于 0)  15375

//Long unknown = null;
//    Object queryReceiveFieldDetailReq=new Object();
//  queryReceiveFieldDetailReq.setOutputNum(1);//CUSTOM_CONVENTION//sourceId:287875_1_15384
//
//    /*M1-允许重置修订[3715]   */
//    Assert.isNull(queryReceiveFieldDetailReq.getOutputNum(),"D1-判断重置修订元素(公共)-M1-允许重置修订-传输数值不能为空",false);
//      unknown = mCustomFields2Service.queryReceiveFieldDetail(queryReceiveFieldDetailReq);
//
//
//      unknown_1 = unknown;
//processBranchName:正常结束 ,processBranchId:15377

            QueryReceiveFieldDetailRespDto receptionServiceRes = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
            receptionServiceReq.setOutputNum(1L);//CUSTOM_CONVENTION//sourceId:287778_1_15379

            /*M1-不允许重置修订[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getOutputNum(), "D1-判断重置修订元素(公共)-M1-不允许重置修订-传输数值不能为空", false);
            receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;

        } else if ((listChangeColumn != null && listChangeColumn != null && listChangeColumn.size() == 0)) {
            //elseif(1-1-02查询底层变更字段列表.底层框架服务变更字段列表数据集条数 等于 0)  15378

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
            receptionServiceReq.setOutputNum(0L);//CUSTOM_CONVENTION//sourceId:287778_1_15379

            /*M1-不允许重置修订[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getOutputNum(), "D1-判断重置修订元素(公共)-M1-不允许重置修订-传输数值不能为空", false);
            receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
//processBranchName:正常结束 ,processBranchId:15380

        }
        JudgeResetReviseElementComRespDto retData = new JudgeResetReviseElementComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setResetRevise(receptionServiceRes_1.getOutputNum());//sourceId:287879_1
        }


        return retData;
    }

    /**
     * D1修订就职记录底层变更字段判断(公共)[4342]
     * gen by moon at 9/6/2022, 12:13:21 AM
     */
    @Trace(operationName = "D1修订就职记录底层变更字段判断(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReviseJudgeBaseChangeColComRespDto reviseJudgeBaseChangeColCom(ReviseJudgeBaseChangeColComReqDto reqDto) {


        ReviseBaseChangeColComRespDto reviseBaseChangeColComRespDto_1 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
            //if(D1修订底层变更字段判断(公共).主体生命周期 等于 正在编辑)  15362

            ReviseBaseChangeColComRespDto reviseBaseChangeColComRespDto = null;
            ReviseBaseChangeColComReqDto reviseBaseChangeColComReqDto = new ReviseBaseChangeColComReqDto();
            if (reqDto != null) {
                reviseBaseChangeColComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:287463_1_15363
                reviseBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//sourceId:287464_1_15363
                reviseBaseChangeColComReqDto.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//sourceId:287461_1_15363
            }

            /*D1修订底层变更字段(公共)[3921]   */
            Assert.isNull(reviseBaseChangeColComReqDto.getTableTypeCode(), "D1修订就职记录底层变更字段判断(公共)-D1修订底层变更字段(公共)-内容表类型编码不能为空", false);
            Assert.isNull(reviseBaseChangeColComReqDto.getEntityId(), "D1修订就职记录底层变更字段判断(公共)-D1修订底层变更字段(公共)-内容表主键ID不能为空", false);
            reviseBaseChangeColComRespDto = reviseBaseChangeColCom(reviseBaseChangeColComReqDto);


            reviseBaseChangeColComRespDto_1 = reviseBaseChangeColComRespDto;
//processBranchName:正常结束 ,processBranchId:15366

        } else {
            //else  15364

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
            if (reqDto != null) {
                receptionServiceReq.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//sourceId:307994_1_15752
            }

            /*M1-传输修订的字段原有值[3715]  用于特殊方法接收上游入参。 */

            receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
//processBranchName:正常结束 ,processBranchId:15365

        }
        ReviseJudgeBaseChangeColComRespDto retData = new ReviseJudgeBaseChangeColComRespDto();
        if (reviseBaseChangeColComRespDto_1 != null) {
            retData.setDirectorInductionRecordId(reviseBaseChangeColComRespDto_1.getDirectorInductionRecordId());//sourceId:287625_1
        }
        if (receptionServiceRes_1 != null) {
            retData.setDirectorInductionRecordId(receptionServiceRes_1.getDirectorInductionRecordId());//sourceId:287625_1
        }


        return retData;
    }

    /**
     * D1-1执行修订底层变更字段(公共)[272]
     * gen by moon at 10/24/2022, 9:43:47 PM
     */
    @Trace(operationName = "D1-1执行修订底层变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColCom(ImplementReviseBaseChangeColComReqDto reqDto) {


        //virtualUsage 1-1-02查内容ID本次已更新字段列表（正在编辑）  15544
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:151656_1_15544
        queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:23597_1_15544
        queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:17175_1_15544
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23614_1_15544
        if (reqDto != null) {
            queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:181698_1_15544
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:17172_1_15544
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:17173_1_15544
        }

        /*1-1-02查内容ID本次已更新字段列表（正在编辑）[8]   */
        Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getEntityId(), "D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(), "D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体批次下更新状态不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getIsInproperties(), "D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


        if ((reqDto != null && reqDto.getBatchId() != null)) {
            //if(D1-1执行修订底层变更字段(公共).批次ID 值不等于空 )  15547

            if ((listChangeColumn != null && listChangeColumn != null && listChangeColumn.size() == 0)) {
                //if(1-1-02查内容ID本次已更新字段列表（正在编辑）.底层框架服务变更字段列表数据集条数 等于 0)  15551

//ModelCode: circulationCollections
                for (ChangeColumnDto circulationCollectionsRes : reqDto.getChangeColumnList()) {

//ModelCode: generateSemanticInstance
                    AutoAenerateSemanticContentRespDto generateSemanticInstanceRes = null;
                    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq = new AutoAenerateSemanticContentReqDto();
                    if (reqDto != null) {
                        generateSemanticInstanceReq.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15600
                    }
                    if (circulationCollectionsRes != null) {
                        generateSemanticInstanceReq.setReviseBehaviorName(circulationCollectionsRes.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15600
                        generateSemanticInstanceReq.setColumnContent(circulationCollectionsRes.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15600
                    }

                    /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
                    Assert.isNull(generateSemanticInstanceReq.getReviseSubjectContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空", false);
                    Assert.isNull(generateSemanticInstanceReq.getReviseBehaviorName(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空", false);
                    Assert.isNull(generateSemanticInstanceReq.getColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空", false);
                    generateSemanticInstanceRes = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq);


                    if ((circulationCollectionsRes != null && circulationCollectionsRes.getOriColumnContent() == null)) {
                        //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  15646

//ModelCode: receptionService
                        QueryReceiveFieldDetailRespDto receptionServiceRes = null;
                        QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
                        receptionServiceReq.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_15647

                        /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
                        Assert.isNull(receptionServiceReq.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空", false);
                        receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);


                        String string = null;
                        ChangeColumn changeColumn = new ChangeColumn();
                        changeColumn.setIsInproperties("TRUE");//sourceId:304307_1_15648
                        changeColumn.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15648
                        if (reqDto != null) {
                            changeColumn.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15648
                            changeColumn.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15648
                            changeColumn.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15648
                            changeColumn.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15648
                            changeColumn.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15648
                            changeColumn.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15648
                            changeColumn.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15648
                            changeColumn.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:304309_1_15648
                            changeColumn.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304317_1_15648
                            changeColumn.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304304_1_15648
                            changeColumn.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15648
                            changeColumn.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15648
                        }
                        if (circulationCollectionsRes != null) {
                            changeColumn.setObjectPropertyCode(circulationCollectionsRes.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15648
                            changeColumn.setMetaDataColumnContent(circulationCollectionsRes.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15648
                            changeColumn.setColumnContent(circulationCollectionsRes.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15648
                        }
                        if (generateSemanticInstanceRes != null) {
                            changeColumn.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15648
                        }
                        if (receptionServiceRes != null) {
                            changeColumn.setOriColumnContent(receptionServiceRes.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15648
                        }

                        /*1-1-02新增底层框架服务变更字段[5]   */
                        Assert.isNull(changeColumn.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空", false);
                        Assert.isNull(changeColumn.getEntityName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空", false);
                        Assert.isNull(changeColumn.getEntityId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空", false);
                        Assert.isNull(changeColumn.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空", false);
                        Assert.isNull(changeColumn.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空", false);
                        Assert.isNull(changeColumn.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空", false);
                        Assert.isNull(changeColumn.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空", false);
                        Assert.isNull(changeColumn.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空", false);
                        Assert.isNull(changeColumn.getIsInproperties(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空", false);
                        Assert.isNull(changeColumn.getSubjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空", false);
                        Assert.isNull(changeColumn.getSubjectChangeType(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空", false);
                        Assert.isNull(changeColumn.getObjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空", false);
                        Assert.isNull(changeColumn.getObjectId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空", false);
                        Assert.isNull(changeColumn.getSubjectUpdateStatus(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空", false);
                        Assert.isNull(changeColumn.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空", false);
                        Assert.isNull(changeColumn.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空", false);
                        string = mChangeColumnService.addBaseChangeColumn(changeColumn);


                    } else {
                        //else  15722

                        String string_2 = null;
                        ChangeColumn changeColumn_1 = new ChangeColumn();
                        changeColumn_1.setIsInproperties("TRUE");//sourceId:304307_1_15723
                        changeColumn_1.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15723
                        if (reqDto != null) {
                            changeColumn_1.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15723
                            changeColumn_1.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15723
                            changeColumn_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15723
                            changeColumn_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15723
                            changeColumn_1.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15723
                            changeColumn_1.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15723
                            changeColumn_1.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15723
                            changeColumn_1.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:304309_1_15723
                            changeColumn_1.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304317_1_15723
                            changeColumn_1.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304304_1_15723
                            changeColumn_1.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15723
                            changeColumn_1.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15723
                        }
                        if (circulationCollectionsRes != null) {
                            changeColumn_1.setObjectPropertyCode(circulationCollectionsRes.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15723
                            changeColumn_1.setMetaDataColumnContent(circulationCollectionsRes.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15723
                            changeColumn_1.setOriColumnContent(circulationCollectionsRes.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15723
                            changeColumn_1.setColumnContent(circulationCollectionsRes.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15723
                        }
                        if (generateSemanticInstanceRes != null) {
                            changeColumn_1.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15723
                        }

                        /*1-1-02新增底层框架服务变更字段[5]   */
                        Assert.isNull(changeColumn_1.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空", false);
                        Assert.isNull(changeColumn_1.getEntityName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空", false);
                        Assert.isNull(changeColumn_1.getEntityId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空", false);
                        Assert.isNull(changeColumn_1.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空", false);
                        Assert.isNull(changeColumn_1.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空", false);
                        Assert.isNull(changeColumn_1.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空", false);
                        Assert.isNull(changeColumn_1.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空", false);
                        Assert.isNull(changeColumn_1.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空", false);
                        Assert.isNull(changeColumn_1.getIsInproperties(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空", false);
                        Assert.isNull(changeColumn_1.getSubjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空", false);
                        Assert.isNull(changeColumn_1.getSubjectChangeType(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空", false);
                        Assert.isNull(changeColumn_1.getObjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空", false);
                        Assert.isNull(changeColumn_1.getObjectId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空", false);
                        Assert.isNull(changeColumn_1.getSubjectUpdateStatus(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空", false);
                        Assert.isNull(changeColumn_1.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空", false);
                        Assert.isNull(changeColumn_1.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空", false);
                        string_2 = mChangeColumnService.addBaseChangeColumn(changeColumn_1);


                    }
//ModelCode: circulationEnd
                }

            } else if ((listChangeColumn != null && listChangeColumn != null && listChangeColumn.size() > 0)) {
                //elseif(1-1-02查内容ID本次已更新字段列表（正在编辑）.底层框架服务变更字段列表数据集条数 大于 0)  15552

//ModelCode: dataAuClassification
                FilterAddUpdateColumnRespDto dataAuClassificationRes = null;
                FilterAddUpdateColumnReqDto dataAuClassificationReq = new FilterAddUpdateColumnReqDto();
                if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn)) {
                    dataAuClassificationReq.setBaseChangeColumnList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:151662_1_15554
                }
                if (reqDto != null && reqDto.getChangeColumnList() != null && !CollectionUtil.isEmpty(reqDto.getChangeColumnList())) {
                    dataAuClassificationReq.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:47370_1_15554
                }

                /*从更新字段中，分类出新增、修改字段（空方法）[908]  入参两个数据集，出参两个数据集，分别对应：新增数据集、删除数据集 */

                dataAuClassificationRes = nbChangeColumn.filterAddUpdateColumn(dataAuClassificationReq);


                if ((dataAuClassificationRes != null && dataAuClassificationRes.getNewColumnList() != null && dataAuClassificationRes.getNewColumnList().size() > 0 && dataAuClassificationRes != null && dataAuClassificationRes.getModifyColumnList() != null && dataAuClassificationRes.getModifyColumnList().size() >= 0)) {
                    //if((从更新字段中，分类出新增、修改字段（空方法）.新增字段分类列表数据集条数 大于 0 and 从更新字段中，分类出新增、修改字段（空方法）.修改字段分类列表数据集条数 大于等于 0))  15555

//ModelCode: circulationCollections
                    for (NewColumnDto circulationCollectionsRes_2 : dataAuClassificationRes.getNewColumnList()) {

//ModelCode: generateSemanticInstance
                        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_2 = null;
                        AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_1 = new AutoAenerateSemanticContentReqDto();
                        if (reqDto != null) {
                            generateSemanticInstanceReq_1.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15602
                        }
                        if (circulationCollectionsRes_2 != null) {
                            generateSemanticInstanceReq_1.setReviseBehaviorName(circulationCollectionsRes_2.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15602
                            generateSemanticInstanceReq_1.setColumnContent(circulationCollectionsRes_2.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15602
                        }

                        /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
                        Assert.isNull(generateSemanticInstanceReq_1.getReviseSubjectContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空", false);
                        Assert.isNull(generateSemanticInstanceReq_1.getReviseBehaviorName(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空", false);
                        Assert.isNull(generateSemanticInstanceReq_1.getColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空", false);
                        generateSemanticInstanceRes_2 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_1);


                        if ((circulationCollectionsRes_2 != null && circulationCollectionsRes_2.getOriColumnContent() == null)) {
                            //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  15649

//ModelCode: receptionService
                            QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
                            QueryReceiveFieldDetailReqDto receptionServiceReq_1 = new QueryReceiveFieldDetailReqDto();
                            receptionServiceReq_1.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_15650

                            /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
                            Assert.isNull(receptionServiceReq_1.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空", false);
                            receptionServiceRes_2 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_1);


                            String string_3 = null;
                            ChangeColumn changeColumn_2 = new ChangeColumn();
                            changeColumn_2.setIsInproperties("TRUE");//sourceId:304307_1_15651
                            changeColumn_2.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15651
                            if (reqDto != null) {
                                changeColumn_2.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15651
                                changeColumn_2.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15651
                                changeColumn_2.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15651
                                changeColumn_2.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15651
                                changeColumn_2.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15651
                                changeColumn_2.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15651
                                changeColumn_2.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15651
                                changeColumn_2.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:304309_1_15651
                                changeColumn_2.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304317_1_15651
                                changeColumn_2.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304304_1_15651
                                changeColumn_2.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15651
                                changeColumn_2.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15651
                            }
                            if (circulationCollectionsRes_2 != null) {
                                changeColumn_2.setObjectPropertyCode(circulationCollectionsRes_2.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15651
                                changeColumn_2.setMetaDataColumnContent(circulationCollectionsRes_2.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15651
                                changeColumn_2.setColumnContent(circulationCollectionsRes_2.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15651
                            }
                            if (generateSemanticInstanceRes_2 != null) {
                                changeColumn_2.setObjectPropertyName(generateSemanticInstanceRes_2.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15651
                            }
                            if (receptionServiceRes_2 != null) {
                                changeColumn_2.setOriColumnContent(receptionServiceRes_2.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15651
                            }

                            /*1-1-02新增底层框架服务变更字段[5]   */
                            Assert.isNull(changeColumn_2.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空", false);
                            Assert.isNull(changeColumn_2.getEntityName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空", false);
                            Assert.isNull(changeColumn_2.getEntityId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空", false);
                            Assert.isNull(changeColumn_2.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空", false);
                            Assert.isNull(changeColumn_2.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空", false);
                            Assert.isNull(changeColumn_2.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空", false);
                            Assert.isNull(changeColumn_2.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_2.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_2.getIsInproperties(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空", false);
                            Assert.isNull(changeColumn_2.getSubjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空", false);
                            Assert.isNull(changeColumn_2.getSubjectChangeType(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空", false);
                            Assert.isNull(changeColumn_2.getObjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空", false);
                            Assert.isNull(changeColumn_2.getObjectId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空", false);
                            Assert.isNull(changeColumn_2.getSubjectUpdateStatus(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空", false);
                            Assert.isNull(changeColumn_2.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空", false);
                            Assert.isNull(changeColumn_2.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空", false);
                            string_3 = mChangeColumnService.addBaseChangeColumn(changeColumn_2);


                        } else {
                            //else  15720

                            String string_4 = null;
                            ChangeColumn changeColumn_3 = new ChangeColumn();
                            changeColumn_3.setIsInproperties("TRUE");//sourceId:304307_1_15721
                            changeColumn_3.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15721
                            if (reqDto != null) {
                                changeColumn_3.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15721
                                changeColumn_3.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15721
                                changeColumn_3.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15721
                                changeColumn_3.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15721
                                changeColumn_3.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15721
                                changeColumn_3.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15721
                                changeColumn_3.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15721
                                changeColumn_3.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:304309_1_15721
                                changeColumn_3.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304317_1_15721
                                changeColumn_3.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304304_1_15721
                                changeColumn_3.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15721
                                changeColumn_3.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15721
                            }
                            if (circulationCollectionsRes_2 != null) {
                                changeColumn_3.setObjectPropertyCode(circulationCollectionsRes_2.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15721
                                changeColumn_3.setMetaDataColumnContent(circulationCollectionsRes_2.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15721
                                changeColumn_3.setOriColumnContent(circulationCollectionsRes_2.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15721
                                changeColumn_3.setColumnContent(circulationCollectionsRes_2.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15721
                            }
                            if (generateSemanticInstanceRes_2 != null) {
                                changeColumn_3.setObjectPropertyName(generateSemanticInstanceRes_2.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15721
                            }

                            /*1-1-02新增底层框架服务变更字段[5]   */
                            Assert.isNull(changeColumn_3.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空", false);
                            Assert.isNull(changeColumn_3.getEntityName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空", false);
                            Assert.isNull(changeColumn_3.getEntityId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空", false);
                            Assert.isNull(changeColumn_3.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空", false);
                            Assert.isNull(changeColumn_3.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空", false);
                            Assert.isNull(changeColumn_3.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空", false);
                            Assert.isNull(changeColumn_3.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_3.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_3.getIsInproperties(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空", false);
                            Assert.isNull(changeColumn_3.getSubjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空", false);
                            Assert.isNull(changeColumn_3.getSubjectChangeType(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空", false);
                            Assert.isNull(changeColumn_3.getObjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空", false);
                            Assert.isNull(changeColumn_3.getObjectId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空", false);
                            Assert.isNull(changeColumn_3.getSubjectUpdateStatus(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空", false);
                            Assert.isNull(changeColumn_3.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空", false);
                            Assert.isNull(changeColumn_3.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空", false);
                            string_4 = mChangeColumnService.addBaseChangeColumn(changeColumn_3);


                        }
//ModelCode: circulationEnd
                    }

                }
                if ((dataAuClassificationRes != null && dataAuClassificationRes.getModifyColumnList() != null && dataAuClassificationRes.getModifyColumnList().size() > 0 && dataAuClassificationRes != null && dataAuClassificationRes.getNewColumnList() != null && dataAuClassificationRes.getNewColumnList().size() >= 0)) {
                    //if((从更新字段中，分类出新增、修改字段（空方法）.修改字段分类列表数据集条数 大于 0 and 从更新字段中，分类出新增、修改字段（空方法）.新增字段分类列表数据集条数 大于等于 0))  15557

//ModelCode: circulationCollections
                    for (ModifyColumnDto circulationCollectionsRes_3 : dataAuClassificationRes.getModifyColumnList()) {

//ModelCode: generateSemanticInstance
                        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_3 = null;
                        AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_2 = new AutoAenerateSemanticContentReqDto();
                        if (reqDto != null) {
                            generateSemanticInstanceReq_2.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15614
                        }
                        if (circulationCollectionsRes_3 != null) {
                            generateSemanticInstanceReq_2.setReviseBehaviorName(circulationCollectionsRes_3.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15614
                            generateSemanticInstanceReq_2.setColumnContent(circulationCollectionsRes_3.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15614
                        }

                        /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
                        Assert.isNull(generateSemanticInstanceReq_2.getReviseSubjectContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空", false);
                        Assert.isNull(generateSemanticInstanceReq_2.getReviseBehaviorName(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空", false);
                        Assert.isNull(generateSemanticInstanceReq_2.getColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空", false);
                        generateSemanticInstanceRes_3 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_2);


                        if ((circulationCollectionsRes_3 != null && circulationCollectionsRes_3.getOriColumnContent() == null)) {
                            //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  16201

//ModelCode: receptionService
                            QueryReceiveFieldDetailRespDto receptionServiceRes_3 = null;
                            QueryReceiveFieldDetailReqDto receptionServiceReq_2 = new QueryReceiveFieldDetailReqDto();
                            receptionServiceReq_2.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_16205

                            /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
                            Assert.isNull(receptionServiceReq_2.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空", false);
                            receptionServiceRes_3 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_2);


                            boolean bOOLEAN;
                            ChangeColumn changeColumn_4 = new ChangeColumn();
                            changeColumn_4.setIsArchive("FALSE");//sourceId:304329_1_16203
                            changeColumn_4.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_16203
                            if (changeColumn_4 != null && changeColumn_4.getSubjectLifeCycle() != null && changeColumn_4.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                                changeColumn_4.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
                            }//sourceId:304326_1_16203
                            if (changeColumn_4 != null && changeColumn_4.getSubjectLifeCycle() != null && changeColumn_4.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                                changeColumn_4.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
                            }//sourceId:304328_1_16203
                            if (circulationCollectionsRes_3 != null) {
                                changeColumn_4.setChangeColumnId(circulationCollectionsRes_3.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_16203
                                changeColumn_4.setObjectPropertyCode(circulationCollectionsRes_3.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_16203
                                changeColumn_4.setMetaDataColumnContent(circulationCollectionsRes_3.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_16203
                                changeColumn_4.setColumnContent(circulationCollectionsRes_3.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_16203
                            }
                            if (generateSemanticInstanceRes_3 != null) {
                                changeColumn_4.setObjectPropertyName(generateSemanticInstanceRes_3.getObjectName());//SimpleFieldAssign//sourceId:304332_1_16203
                            }
                            if (receptionServiceRes_3 != null) {
                                changeColumn_4.setOriColumnContent(receptionServiceRes_3.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_16203
                            }
                            if (reqDto != null) {
                                changeColumn_4.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304322_1_16203
                                changeColumn_4.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304323_1_16203
                                changeColumn_4.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_16203
                                changeColumn_4.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_16203
                            }

                            /*1-1-02修改底层变更字段[6]   */
                            Assert.isNull(changeColumn_4.getChangeColumnId(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空", false);
                            Assert.isNull(changeColumn_4.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空", false);
                            Assert.isNull(changeColumn_4.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空", false);
                            Assert.isNull(changeColumn_4.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空", false);
                            Assert.isNull(changeColumn_4.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_4.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_4.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空", false);
                            Assert.isNull(changeColumn_4.getIsArchive(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空", false);
                            Assert.isNull(changeColumn_4.getArchivngType(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空", false);
                            Assert.isNull(changeColumn_4.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空", false);
                            bOOLEAN = mChangeColumnService.updateBaseChangeCol(changeColumn_4);


                        } else {
                            //else  16202

                            boolean bOOLEAN_1;
                            ChangeColumn changeColumn_5 = new ChangeColumn();
                            changeColumn_5.setIsArchive("FALSE");//sourceId:304329_1_16204
                            changeColumn_5.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_16204
                            if (changeColumn_5 != null && changeColumn_5.getSubjectLifeCycle() != null && changeColumn_5.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                                changeColumn_5.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
                            }//sourceId:304326_1_16204
                            if (changeColumn_5 != null && changeColumn_5.getSubjectLifeCycle() != null && changeColumn_5.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                                changeColumn_5.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
                            }//sourceId:304328_1_16204
                            if (circulationCollectionsRes_3 != null) {
                                changeColumn_5.setChangeColumnId(circulationCollectionsRes_3.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_16204
                                changeColumn_5.setObjectPropertyCode(circulationCollectionsRes_3.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_16204
                                changeColumn_5.setMetaDataColumnContent(circulationCollectionsRes_3.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_16204
                                changeColumn_5.setOriColumnContent(circulationCollectionsRes_3.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_16204
                                changeColumn_5.setColumnContent(circulationCollectionsRes_3.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_16204
                            }
                            if (generateSemanticInstanceRes_3 != null) {
                                changeColumn_5.setObjectPropertyName(generateSemanticInstanceRes_3.getObjectName());//SimpleFieldAssign//sourceId:304332_1_16204
                            }
                            if (reqDto != null) {
                                changeColumn_5.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304322_1_16204
                                changeColumn_5.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304323_1_16204
                                changeColumn_5.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_16204
                                changeColumn_5.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_16204
                            }

                            /*1-1-02修改底层变更字段[6]   */
                            Assert.isNull(changeColumn_5.getChangeColumnId(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空", false);
                            Assert.isNull(changeColumn_5.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空", false);
                            Assert.isNull(changeColumn_5.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空", false);
                            Assert.isNull(changeColumn_5.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空", false);
                            Assert.isNull(changeColumn_5.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_5.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_5.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空", false);
                            Assert.isNull(changeColumn_5.getIsArchive(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空", false);
                            Assert.isNull(changeColumn_5.getArchivngType(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空", false);
                            Assert.isNull(changeColumn_5.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空", false);
                            bOOLEAN_1 = mChangeColumnService.updateBaseChangeCol(changeColumn_5);


                        }
                        boolean bOOLEAN_2;
                        ChangeColumn changeColumn_6 = new ChangeColumn();
                        changeColumn_6.setIsArchive("FALSE");//sourceId:304329_1_15615
                        changeColumn_6.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_15615
                        if (changeColumn_6 != null && changeColumn_6.getSubjectLifeCycle() != null && changeColumn_6.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                            changeColumn_6.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
                        }//sourceId:304326_1_15615
                        if (changeColumn_6 != null && changeColumn_6.getSubjectLifeCycle() != null && changeColumn_6.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                            changeColumn_6.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
                        }//sourceId:304328_1_15615
                        if (circulationCollectionsRes_3 != null) {
                            changeColumn_6.setChangeColumnId(circulationCollectionsRes_3.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_15615
                            changeColumn_6.setObjectPropertyCode(circulationCollectionsRes_3.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_15615
                            changeColumn_6.setMetaDataColumnContent(circulationCollectionsRes_3.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_15615
                            changeColumn_6.setOriColumnContent(circulationCollectionsRes_3.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_15615
                            changeColumn_6.setColumnContent(circulationCollectionsRes_3.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_15615
                        }
                        if (generateSemanticInstanceRes_3 != null) {
                            changeColumn_6.setObjectPropertyName(generateSemanticInstanceRes_3.getObjectName());//SimpleFieldAssign//sourceId:304332_1_15615
                        }
                        if (reqDto != null) {
                            changeColumn_6.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304322_1_15615
                            changeColumn_6.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304323_1_15615
                            changeColumn_6.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_15615
                            changeColumn_6.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_15615
                        }

                        /*1-1-02修改底层变更字段[6]   */
                        Assert.isNull(changeColumn_6.getChangeColumnId(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空", false);
                        Assert.isNull(changeColumn_6.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空", false);
                        Assert.isNull(changeColumn_6.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空", false);
                        Assert.isNull(changeColumn_6.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空", false);
                        Assert.isNull(changeColumn_6.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空", false);
                        Assert.isNull(changeColumn_6.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空", false);
                        Assert.isNull(changeColumn_6.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空", false);
                        Assert.isNull(changeColumn_6.getIsArchive(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空", false);
                        Assert.isNull(changeColumn_6.getArchivngType(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空", false);
                        Assert.isNull(changeColumn_6.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空", false);
                        bOOLEAN_2 = mChangeColumnService.updateBaseChangeCol(changeColumn_6);


//ModelCode: circulationEnd
                    }

                }
            }
        } else if ((reqDto != null && reqDto.getBatchId() == null)) {
            //elseif(D1-1执行修订底层变更字段(公共).批次ID 值等于空 )  15549

            if ((listChangeColumn != null && listChangeColumn != null && listChangeColumn.size() == 0)) {
                //if(1-1-02查内容ID本次已更新字段列表（正在编辑）.底层框架服务变更字段列表数据集条数 等于 0)  15562

//ModelCode: circulationCollections
                for (ChangeColumnDto circulationCollectionsRes_4 : reqDto.getChangeColumnList()) {

//ModelCode: generateSemanticInstance
                    AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_4 = null;
                    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_3 = new AutoAenerateSemanticContentReqDto();
                    if (reqDto != null) {
                        generateSemanticInstanceReq_3.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15606
                    }
                    if (circulationCollectionsRes_4 != null) {
                        generateSemanticInstanceReq_3.setReviseBehaviorName(circulationCollectionsRes_4.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15606
                        generateSemanticInstanceReq_3.setColumnContent(circulationCollectionsRes_4.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15606
                    }

                    /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
                    Assert.isNull(generateSemanticInstanceReq_3.getReviseSubjectContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空", false);
                    Assert.isNull(generateSemanticInstanceReq_3.getReviseBehaviorName(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空", false);
                    Assert.isNull(generateSemanticInstanceReq_3.getColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空", false);
                    generateSemanticInstanceRes_4 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_3);


                    if ((circulationCollectionsRes_4 != null && circulationCollectionsRes_4.getOriColumnContent() == null)) {
                        //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  15652

//ModelCode: receptionService
                        QueryReceiveFieldDetailRespDto receptionServiceRes_4 = null;
                        QueryReceiveFieldDetailReqDto receptionServiceReq_3 = new QueryReceiveFieldDetailReqDto();
                        receptionServiceReq_3.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_15653

                        /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
                        Assert.isNull(receptionServiceReq_3.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空", false);
                        receptionServiceRes_4 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_3);


                        String string_5 = null;
                        ChangeColumn changeColumn_7 = new ChangeColumn();
                        changeColumn_7.setIsInproperties("TRUE");//sourceId:304307_1_15654
                        changeColumn_7.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15654
                        if (reqDto != null) {
                            changeColumn_7.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15654
                            changeColumn_7.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15654
                            changeColumn_7.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15654
                            changeColumn_7.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15654
                            changeColumn_7.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15654
                            changeColumn_7.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15654
                            changeColumn_7.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15654
                            changeColumn_7.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15654
                            changeColumn_7.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15654
                        }
                        if (circulationCollectionsRes_4 != null) {
                            changeColumn_7.setObjectPropertyCode(circulationCollectionsRes_4.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15654
                            changeColumn_7.setMetaDataColumnContent(circulationCollectionsRes_4.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15654
                            changeColumn_7.setColumnContent(circulationCollectionsRes_4.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15654
                        }
                        if (generateSemanticInstanceRes_4 != null) {
                            changeColumn_7.setObjectPropertyName(generateSemanticInstanceRes_4.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15654
                        }
                        if (receptionServiceRes_4 != null) {
                            changeColumn_7.setOriColumnContent(receptionServiceRes_4.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15654
                        }

                        /*1-1-02新增底层框架服务变更字段[5]   */
                        Assert.isNull(changeColumn_7.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空", false);
                        Assert.isNull(changeColumn_7.getEntityName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空", false);
                        Assert.isNull(changeColumn_7.getEntityId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空", false);
                        Assert.isNull(changeColumn_7.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空", false);
                        Assert.isNull(changeColumn_7.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空", false);
                        Assert.isNull(changeColumn_7.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空", false);
                        Assert.isNull(changeColumn_7.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空", false);
                        Assert.isNull(changeColumn_7.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空", false);
                        Assert.isNull(changeColumn_7.getIsInproperties(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空", false);
                        Assert.isNull(changeColumn_7.getSubjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空", false);
                        Assert.isNull(changeColumn_7.getSubjectChangeType(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空", false);
                        Assert.isNull(changeColumn_7.getObjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空", false);
                        Assert.isNull(changeColumn_7.getObjectId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空", false);
                        Assert.isNull(changeColumn_7.getSubjectUpdateStatus(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空", false);
                        Assert.isNull(changeColumn_7.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空", false);
                        Assert.isNull(changeColumn_7.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空", false);
                        string_5 = mChangeColumnService.addBaseChangeColumn(changeColumn_7);


                    } else {
                        //else  15718

                        String string_6 = null;
                        ChangeColumn changeColumn_8 = new ChangeColumn();
                        changeColumn_8.setIsInproperties("TRUE");//sourceId:304307_1_15719
                        changeColumn_8.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15719
                        if (reqDto != null) {
                            changeColumn_8.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15719
                            changeColumn_8.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15719
                            changeColumn_8.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15719
                            changeColumn_8.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15719
                            changeColumn_8.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15719
                            changeColumn_8.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15719
                            changeColumn_8.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15719
                            changeColumn_8.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15719
                            changeColumn_8.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15719
                        }
                        if (circulationCollectionsRes_4 != null) {
                            changeColumn_8.setObjectPropertyCode(circulationCollectionsRes_4.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15719
                            changeColumn_8.setMetaDataColumnContent(circulationCollectionsRes_4.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15719
                            changeColumn_8.setOriColumnContent(circulationCollectionsRes_4.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15719
                            changeColumn_8.setColumnContent(circulationCollectionsRes_4.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15719
                        }
                        if (generateSemanticInstanceRes_4 != null) {
                            changeColumn_8.setObjectPropertyName(generateSemanticInstanceRes_4.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15719
                        }

                        /*1-1-02新增底层框架服务变更字段[5]   */
                        Assert.isNull(changeColumn_8.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空", false);
                        Assert.isNull(changeColumn_8.getEntityName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空", false);
                        Assert.isNull(changeColumn_8.getEntityId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空", false);
                        Assert.isNull(changeColumn_8.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空", false);
                        Assert.isNull(changeColumn_8.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空", false);
                        Assert.isNull(changeColumn_8.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空", false);
                        Assert.isNull(changeColumn_8.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空", false);
                        Assert.isNull(changeColumn_8.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空", false);
                        Assert.isNull(changeColumn_8.getIsInproperties(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空", false);
                        Assert.isNull(changeColumn_8.getSubjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空", false);
                        Assert.isNull(changeColumn_8.getSubjectChangeType(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空", false);
                        Assert.isNull(changeColumn_8.getObjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空", false);
                        Assert.isNull(changeColumn_8.getObjectId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空", false);
                        Assert.isNull(changeColumn_8.getSubjectUpdateStatus(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空", false);
                        Assert.isNull(changeColumn_8.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空", false);
                        Assert.isNull(changeColumn_8.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空", false);
                        string_6 = mChangeColumnService.addBaseChangeColumn(changeColumn_8);


                    }
//ModelCode: circulationEnd
                }

            } else if ((listChangeColumn != null && listChangeColumn != null && listChangeColumn.size() > 0)) {
                //elseif(1-1-02查内容ID本次已更新字段列表（正在编辑）.底层框架服务变更字段列表数据集条数 大于 0)  15563

//ModelCode: dataAuClassification
                FilterAddUpdateColumnRespDto dataAuClassificationRes_2 = null;
                FilterAddUpdateColumnReqDto dataAuClassificationReq_1 = new FilterAddUpdateColumnReqDto();
                if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn)) {
                    dataAuClassificationReq_1.setBaseChangeColumnList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:151662_1_15565
                }
                if (reqDto != null && reqDto.getChangeColumnList() != null && !CollectionUtil.isEmpty(reqDto.getChangeColumnList())) {
                    dataAuClassificationReq_1.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:47370_1_15565
                }

                /*从更新字段中，分类出新增、修改字段（空方法）[908]  入参两个数据集，出参两个数据集，分别对应：新增数据集、删除数据集 */

                dataAuClassificationRes_2 = nbChangeColumn.filterAddUpdateColumn(dataAuClassificationReq_1);


                if ((dataAuClassificationRes_2 != null && dataAuClassificationRes_2.getNewColumnList() != null && dataAuClassificationRes_2.getNewColumnList().size() > 0 && dataAuClassificationRes_2 != null && dataAuClassificationRes_2.getModifyColumnList() != null && dataAuClassificationRes_2.getModifyColumnList().size() >= 0)) {
                    //if((从更新字段中，分类出新增、修改字段（空方法）.新增字段分类列表数据集条数 大于 0 and 从更新字段中，分类出新增、修改字段（空方法）.修改字段分类列表数据集条数 大于等于 0))  15566

//ModelCode: circulationCollections
                    for (NewColumnDto circulationCollectionsRes_5 : dataAuClassificationRes_2.getNewColumnList()) {

//ModelCode: generateSemanticInstance
                        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_5 = null;
                        AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_4 = new AutoAenerateSemanticContentReqDto();
                        if (reqDto != null) {
                            generateSemanticInstanceReq_4.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15610
                        }
                        if (circulationCollectionsRes_5 != null) {
                            generateSemanticInstanceReq_4.setReviseBehaviorName(circulationCollectionsRes_5.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15610
                            generateSemanticInstanceReq_4.setColumnContent(circulationCollectionsRes_5.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15610
                        }

                        /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
                        Assert.isNull(generateSemanticInstanceReq_4.getReviseSubjectContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空", false);
                        Assert.isNull(generateSemanticInstanceReq_4.getReviseBehaviorName(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空", false);
                        Assert.isNull(generateSemanticInstanceReq_4.getColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空", false);
                        generateSemanticInstanceRes_5 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_4);


                        if ((circulationCollectionsRes_5 != null && circulationCollectionsRes_5.getOriColumnContent() == null)) {
                            //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  15655

//ModelCode: receptionService
                            QueryReceiveFieldDetailRespDto receptionServiceRes_5 = null;
                            QueryReceiveFieldDetailReqDto receptionServiceReq_4 = new QueryReceiveFieldDetailReqDto();
                            receptionServiceReq_4.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_15656

                            /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
                            Assert.isNull(receptionServiceReq_4.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空", false);
                            receptionServiceRes_5 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_4);


                            String string_7 = null;
                            ChangeColumn changeColumn_9 = new ChangeColumn();
                            changeColumn_9.setIsInproperties("TRUE");//sourceId:304307_1_15657
                            changeColumn_9.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15657
                            if (reqDto != null) {
                                changeColumn_9.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15657
                                changeColumn_9.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15657
                                changeColumn_9.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15657
                                changeColumn_9.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15657
                                changeColumn_9.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15657
                                changeColumn_9.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15657
                                changeColumn_9.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15657
                                changeColumn_9.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15657
                                changeColumn_9.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15657
                            }
                            if (circulationCollectionsRes_5 != null) {
                                changeColumn_9.setObjectPropertyCode(circulationCollectionsRes_5.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15657
                                changeColumn_9.setMetaDataColumnContent(circulationCollectionsRes_5.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15657
                                changeColumn_9.setColumnContent(circulationCollectionsRes_5.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15657
                            }
                            if (generateSemanticInstanceRes_5 != null) {
                                changeColumn_9.setObjectPropertyName(generateSemanticInstanceRes_5.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15657
                            }
                            if (receptionServiceRes_5 != null) {
                                changeColumn_9.setOriColumnContent(receptionServiceRes_5.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15657
                            }

                            /*1-1-02新增底层框架服务变更字段[5]   */
                            Assert.isNull(changeColumn_9.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空", false);
                            Assert.isNull(changeColumn_9.getEntityName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空", false);
                            Assert.isNull(changeColumn_9.getEntityId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空", false);
                            Assert.isNull(changeColumn_9.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空", false);
                            Assert.isNull(changeColumn_9.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空", false);
                            Assert.isNull(changeColumn_9.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空", false);
                            Assert.isNull(changeColumn_9.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_9.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_9.getIsInproperties(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空", false);
                            Assert.isNull(changeColumn_9.getSubjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空", false);
                            Assert.isNull(changeColumn_9.getSubjectChangeType(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空", false);
                            Assert.isNull(changeColumn_9.getObjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空", false);
                            Assert.isNull(changeColumn_9.getObjectId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空", false);
                            Assert.isNull(changeColumn_9.getSubjectUpdateStatus(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空", false);
                            Assert.isNull(changeColumn_9.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空", false);
                            Assert.isNull(changeColumn_9.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空", false);
                            string_7 = mChangeColumnService.addBaseChangeColumn(changeColumn_9);


                        } else {
                            //else  15716

                            String string_8 = null;
                            ChangeColumn changeColumn_10 = new ChangeColumn();
                            changeColumn_10.setIsInproperties("TRUE");//sourceId:304307_1_15717
                            changeColumn_10.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15717
                            if (reqDto != null) {
                                changeColumn_10.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15717
                                changeColumn_10.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15717
                                changeColumn_10.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15717
                                changeColumn_10.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15717
                                changeColumn_10.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15717
                                changeColumn_10.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15717
                                changeColumn_10.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15717
                                changeColumn_10.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15717
                                changeColumn_10.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15717
                            }
                            if (circulationCollectionsRes_5 != null) {
                                changeColumn_10.setObjectPropertyCode(circulationCollectionsRes_5.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15717
                                changeColumn_10.setMetaDataColumnContent(circulationCollectionsRes_5.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15717
                                changeColumn_10.setOriColumnContent(circulationCollectionsRes_5.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15717
                                changeColumn_10.setColumnContent(circulationCollectionsRes_5.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15717
                            }
                            if (generateSemanticInstanceRes_5 != null) {
                                changeColumn_10.setObjectPropertyName(generateSemanticInstanceRes_5.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15717
                            }

                            /*1-1-02新增底层框架服务变更字段[5]   */
                            Assert.isNull(changeColumn_10.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空", false);
                            Assert.isNull(changeColumn_10.getEntityName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空", false);
                            Assert.isNull(changeColumn_10.getEntityId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空", false);
                            Assert.isNull(changeColumn_10.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空", false);
                            Assert.isNull(changeColumn_10.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空", false);
                            Assert.isNull(changeColumn_10.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空", false);
                            Assert.isNull(changeColumn_10.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_10.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_10.getIsInproperties(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空", false);
                            Assert.isNull(changeColumn_10.getSubjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空", false);
                            Assert.isNull(changeColumn_10.getSubjectChangeType(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空", false);
                            Assert.isNull(changeColumn_10.getObjectTypeCode(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空", false);
                            Assert.isNull(changeColumn_10.getObjectId(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空", false);
                            Assert.isNull(changeColumn_10.getSubjectUpdateStatus(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空", false);
                            Assert.isNull(changeColumn_10.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空", false);
                            Assert.isNull(changeColumn_10.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空", false);
                            string_8 = mChangeColumnService.addBaseChangeColumn(changeColumn_10);


                        }
//ModelCode: circulationEnd
                    }

                }
                if ((dataAuClassificationRes_2 != null && dataAuClassificationRes_2.getModifyColumnList() != null && dataAuClassificationRes_2.getModifyColumnList().size() > 0 && dataAuClassificationRes_2 != null && dataAuClassificationRes_2.getNewColumnList() != null && dataAuClassificationRes_2.getNewColumnList().size() >= 0)) {
                    //if((从更新字段中，分类出新增、修改字段（空方法）.修改字段分类列表数据集条数 大于 0 and 从更新字段中，分类出新增、修改字段（空方法）.新增字段分类列表数据集条数 大于等于 0))  15570

//ModelCode: circulationCollections
                    for (ModifyColumnDto circulationCollectionsRes_6 : dataAuClassificationRes_2.getModifyColumnList()) {

//ModelCode: generateSemanticInstance
                        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_6 = null;
                        AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_5 = new AutoAenerateSemanticContentReqDto();
                        if (reqDto != null) {
                            generateSemanticInstanceReq_5.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15618
                        }
                        if (circulationCollectionsRes_6 != null) {
                            generateSemanticInstanceReq_5.setReviseBehaviorName(circulationCollectionsRes_6.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15618
                            generateSemanticInstanceReq_5.setColumnContent(circulationCollectionsRes_6.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15618
                        }

                        /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
                        Assert.isNull(generateSemanticInstanceReq_5.getReviseSubjectContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空", false);
                        Assert.isNull(generateSemanticInstanceReq_5.getReviseBehaviorName(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空", false);
                        Assert.isNull(generateSemanticInstanceReq_5.getColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空", false);
                        generateSemanticInstanceRes_6 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_5);


                        if ((circulationCollectionsRes_6 != null && circulationCollectionsRes_6.getOriColumnContent() == null)) {
                            //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  16196

//ModelCode: receptionService
                            QueryReceiveFieldDetailRespDto receptionServiceRes_6 = null;
                            QueryReceiveFieldDetailReqDto receptionServiceReq_5 = new QueryReceiveFieldDetailReqDto();
                            receptionServiceReq_5.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_16200

                            /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
                            Assert.isNull(receptionServiceReq_5.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空", false);
                            receptionServiceRes_6 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_5);


                            boolean bOOLEAN_3;
                            ChangeColumn changeColumn_11 = new ChangeColumn();
                            changeColumn_11.setIsArchive("FALSE");//sourceId:304329_1_16197
                            changeColumn_11.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_16197
                            if (changeColumn_11 != null && changeColumn_11.getSubjectLifeCycle() != null && changeColumn_11.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                                changeColumn_11.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
                            }//sourceId:304326_1_16197
                            if (changeColumn_11 != null && changeColumn_11.getSubjectLifeCycle() != null && changeColumn_11.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                                changeColumn_11.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
                            }//sourceId:304328_1_16197
                            if (circulationCollectionsRes_6 != null) {
                                changeColumn_11.setChangeColumnId(circulationCollectionsRes_6.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_16197
                                changeColumn_11.setObjectPropertyCode(circulationCollectionsRes_6.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_16197
                                changeColumn_11.setMetaDataColumnContent(circulationCollectionsRes_6.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_16197
                                changeColumn_11.setColumnContent(circulationCollectionsRes_6.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_16197
                            }
                            if (generateSemanticInstanceRes_6 != null) {
                                changeColumn_11.setObjectPropertyName(generateSemanticInstanceRes_6.getObjectName());//SimpleFieldAssign//sourceId:304332_1_16197
                            }
                            if (receptionServiceRes_6 != null) {
                                changeColumn_11.setOriColumnContent(receptionServiceRes_6.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_16197
                            }
                            if (reqDto != null) {
                                changeColumn_11.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_16197
                                changeColumn_11.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_16197
                            }

                            /*1-1-02修改底层变更字段[6]   */
                            Assert.isNull(changeColumn_11.getChangeColumnId(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空", false);
                            Assert.isNull(changeColumn_11.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空", false);
                            Assert.isNull(changeColumn_11.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空", false);
                            Assert.isNull(changeColumn_11.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空", false);
                            Assert.isNull(changeColumn_11.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_11.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_11.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空", false);
                            Assert.isNull(changeColumn_11.getIsArchive(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空", false);
                            Assert.isNull(changeColumn_11.getArchivngType(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空", false);
                            Assert.isNull(changeColumn_11.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空", false);
                            bOOLEAN_3 = mChangeColumnService.updateBaseChangeCol(changeColumn_11);


                        } else {
                            //else  16198

                            boolean bOOLEAN_4;
                            ChangeColumn changeColumn_12 = new ChangeColumn();
                            changeColumn_12.setIsArchive("FALSE");//sourceId:304329_1_16199
                            changeColumn_12.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_16199
                            if (changeColumn_12 != null && changeColumn_12.getSubjectLifeCycle() != null && changeColumn_12.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                                changeColumn_12.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
                            }//sourceId:304326_1_16199
                            if (changeColumn_12 != null && changeColumn_12.getSubjectLifeCycle() != null && changeColumn_12.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
                                changeColumn_12.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
                            }//sourceId:304328_1_16199
                            if (circulationCollectionsRes_6 != null) {
                                changeColumn_12.setChangeColumnId(circulationCollectionsRes_6.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_16199
                                changeColumn_12.setObjectPropertyCode(circulationCollectionsRes_6.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_16199
                                changeColumn_12.setMetaDataColumnContent(circulationCollectionsRes_6.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_16199
                                changeColumn_12.setOriColumnContent(circulationCollectionsRes_6.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_16199
                                changeColumn_12.setColumnContent(circulationCollectionsRes_6.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_16199
                            }
                            if (generateSemanticInstanceRes_6 != null) {
                                changeColumn_12.setObjectPropertyName(generateSemanticInstanceRes_6.getObjectName());//SimpleFieldAssign//sourceId:304332_1_16199
                            }
                            if (reqDto != null) {
                                changeColumn_12.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_16199
                                changeColumn_12.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_16199
                            }

                            /*1-1-02修改底层变更字段[6]   */
                            Assert.isNull(changeColumn_12.getChangeColumnId(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空", false);
                            Assert.isNull(changeColumn_12.getObjectPropertyCode(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空", false);
                            Assert.isNull(changeColumn_12.getObjectPropertyName(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空", false);
                            Assert.isNull(changeColumn_12.getMetaDataColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空", false);
                            Assert.isNull(changeColumn_12.getOriColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_12.getColumnContent(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空", false);
                            Assert.isNull(changeColumn_12.getIsEditing(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空", false);
                            Assert.isNull(changeColumn_12.getIsArchive(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空", false);
                            Assert.isNull(changeColumn_12.getArchivngType(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空", false);
                            Assert.isNull(changeColumn_12.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空", false);
                            bOOLEAN_4 = mChangeColumnService.updateBaseChangeCol(changeColumn_12);


                        }
//ModelCode: circulationEnd
                    }

                }
            }
            if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))) {
                //if(D1-1执行修订底层变更字段(公共).主体生命周期 等于 当前有效)  15587

                BatchWriteBackBaseChangeColComRespDto batchWriteBackBaseChangeColComRespDto = null;
                BatchWriteBackBaseChangeColComReqDto batchWriteBackBaseChangeColComReqDto = new BatchWriteBackBaseChangeColComReqDto();
                if (reqDto != null) {
                    batchWriteBackBaseChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:306207_1_15671
                    batchWriteBackBaseChangeColComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:306208_1_15671
                    batchWriteBackBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:306209_1_15671
                    batchWriteBackBaseChangeColComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:306210_1_15671
                    batchWriteBackBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:306211_1_15671
                    batchWriteBackBaseChangeColComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:306212_1_15671
                }

                /*D1批量回写底层变更字段(公共)[4382]   */
                Assert.isNull(batchWriteBackBaseChangeColComReqDto.getTableTypeCode(), "D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-内容表类型编码不能为空", false);
                Assert.isNull(batchWriteBackBaseChangeColComReqDto.getEntityId(), "D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-内容表主键ID不能为空", false);
                Assert.isNull(batchWriteBackBaseChangeColComReqDto.getObjectTypeCode(), "D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-归属对象类型编码不能为空", false);
                Assert.isNull(batchWriteBackBaseChangeColComReqDto.getObjectId(), "D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-归属对象内容ID不能为空", false);
                Assert.isNull(batchWriteBackBaseChangeColComReqDto.getSubjectLifeCycle(), "D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-主体生命周期不能为空", false);
                batchWriteBackBaseChangeColComRespDto = batchWriteBackBaseChangeColCom(batchWriteBackBaseChangeColComReqDto);


            }
        }
//processBranchName:正常结束 ,processBranchId:15592

        ImplementReviseBaseChangeColComRespDto retData = new ImplementReviseBaseChangeColComRespDto();


        return retData;
    }

    /**
     * D1-1判断生命周期底层变更字段[4344]
     * gen by moon at 9/2/2022, 5:45:26 PM
     */
    @Trace(operationName = "D1-1判断生命周期底层变更字段")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeSubjectLifeCycleBaseChangeColRespDto judgeSubjectLifeCycleBaseChangeCol(JudgeSubjectLifeCycleBaseChangeColReqDto reqDto) {


        if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
            //if(D1-1判断生命周期底层变更字段.主体生命周期 等于 正在编辑)  15396

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
            receptionServiceReq.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:288137_1_15400
            receptionServiceReq.setIsEditing("TRUE");//sourceId:288142_1_15400
            receptionServiceReq.setSubjectLifeCycle("EDITING");//sourceId:288129_1_15400
            if (reqDto != null) {
                receptionServiceReq.setBatchId(reqDto.getBatchId());//sourceId:288127_1_15400
            }

            /*M1-生命周期正在编辑[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getIsEditing(), "D1-1判断生命周期底层变更字段-M1-生命周期正在编辑-是否未来不能为空", false);
            Assert.isNull(receptionServiceReq.getSubjectLifeCycle(), "D1-1判断生命周期底层变更字段-M1-生命周期正在编辑-主体生命周期不能为空", false);
            receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);


            ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto = null;
            ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto = new ImplementReviseBaseChangeColComReqDto();
            if (receptionServiceRes != null) {
                implementReviseBaseChangeColComReqDto.setBatchId(receptionServiceRes.getBatchId());//sourceId:288002_1_15398
                implementReviseBaseChangeColComReqDto.setBatchEndTime(receptionServiceRes.getBatchEndTime());//sourceId:287998_1_15398
                implementReviseBaseChangeColComReqDto.setIsEditing(receptionServiceRes.getIsEditing());//sourceId:287999_1_15398
                implementReviseBaseChangeColComReqDto.setSubjectLifeCycle(receptionServiceRes.getSubjectLifeCycle());//sourceId:288000_1_15398
            }
            if (reqDto != null) {
                implementReviseBaseChangeColComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:287990_1_15398
                implementReviseBaseChangeColComReqDto.setEntityName(reqDto.getEntityName());//sourceId:288001_1_15398
                implementReviseBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//sourceId:287991_1_15398
                implementReviseBaseChangeColComReqDto.setSubjectTypeCode(reqDto.getSubjectTypeCode());//sourceId:287993_1_15398
                implementReviseBaseChangeColComReqDto.setSubjectChangeType(reqDto.getSubjectChangeType());//sourceId:287994_1_15398
                implementReviseBaseChangeColComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:287995_1_15398
                implementReviseBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//sourceId:287996_1_15398
                implementReviseBaseChangeColComReqDto.setChangeColumnList(reqDto.getChangeColumnList());//sourceId:287992_1_15398
                implementReviseBaseChangeColComReqDto.setReviseSubjectContent(reqDto.getReviseSubjectContent());//sourceId:288003_1_15398
            }

            /*D1-1执行修订底层变更字段(正在编辑)[272]   */
            Assert.isNull(implementReviseBaseChangeColComReqDto.getIsEditing(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-是否未来不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectLifeCycle(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-主体生命周期不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getTableTypeCode(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-内容表类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getEntityName(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-内容表主键行为日志英文名称不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getEntityId(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-内容表主键ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectTypeCode(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-主体类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectChangeType(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-主体变更日志类型不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getObjectTypeCode(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-归属对象类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getObjectId(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-归属对象内容ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getReviseSubjectContent(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-修订主体内容不能为空", false);
            implementReviseBaseChangeColComRespDto = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto);


//processBranchName:正常结束 ,processBranchId:15402

        } else if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))) {
            //elseif(D1-1判断生命周期底层变更字段.主体生命周期 等于 当前有效)  15397

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_1 = new QueryReceiveFieldDetailReqDto();
            receptionServiceReq_1.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:288252_1_15401
            receptionServiceReq_1.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:288253_1_15401
            receptionServiceReq_1.setIsEditing("FALSE");//sourceId:288249_1_15401
            receptionServiceReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:288250_1_15401
            if (reqDto != null) {
                receptionServiceReq_1.setBatchId(reqDto.getBatchId());//sourceId:288251_1_15401
            }

            /*M1-生命周期当前有效[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getIsEditing(), "D1-1判断生命周期底层变更字段-M1-生命周期当前有效-是否未来不能为空", false);
            Assert.isNull(receptionServiceReq_1.getSubjectLifeCycle(), "D1-1判断生命周期底层变更字段-M1-生命周期当前有效-主体生命周期不能为空", false);
            receptionServiceRes_2 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_1);


            ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto_1 = null;
            ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto_1 = new ImplementReviseBaseChangeColComReqDto();
            if (receptionServiceRes_2 != null) {
                implementReviseBaseChangeColComReqDto_1.setBatchId(receptionServiceRes_2.getBatchId());//sourceId:288016_1_15399
                implementReviseBaseChangeColComReqDto_1.setBatchStartTime(receptionServiceRes_2.getBatchStartTime());//sourceId:288011_1_15399
                implementReviseBaseChangeColComReqDto_1.setBatchEndTime(receptionServiceRes_2.getBatchEndTime());//sourceId:288012_1_15399
                implementReviseBaseChangeColComReqDto_1.setIsEditing(receptionServiceRes_2.getIsEditing());//sourceId:288013_1_15399
                implementReviseBaseChangeColComReqDto_1.setSubjectLifeCycle(receptionServiceRes_2.getSubjectLifeCycle());//sourceId:288014_1_15399
            }
            if (reqDto != null) {
                implementReviseBaseChangeColComReqDto_1.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:288004_1_15399
                implementReviseBaseChangeColComReqDto_1.setEntityName(reqDto.getEntityName());//sourceId:288015_1_15399
                implementReviseBaseChangeColComReqDto_1.setEntityId(reqDto.getEntityId());//sourceId:288005_1_15399
                implementReviseBaseChangeColComReqDto_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//sourceId:288007_1_15399
                implementReviseBaseChangeColComReqDto_1.setSubjectChangeType(reqDto.getSubjectChangeType());//sourceId:288008_1_15399
                implementReviseBaseChangeColComReqDto_1.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:288009_1_15399
                implementReviseBaseChangeColComReqDto_1.setObjectId(reqDto.getObjectId());//sourceId:288010_1_15399
                implementReviseBaseChangeColComReqDto_1.setChangeColumnList(reqDto.getChangeColumnList());//sourceId:288006_1_15399
                implementReviseBaseChangeColComReqDto_1.setReviseSubjectContent(reqDto.getReviseSubjectContent());//sourceId:288017_1_15399
            }

            /*D1-1执行修订底层变更字段(当前有效)[272]   */
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getIsEditing(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-是否未来不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectLifeCycle(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-主体生命周期不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getTableTypeCode(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-内容表类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getEntityName(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-内容表主键行为日志英文名称不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getEntityId(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-内容表主键ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectTypeCode(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-主体类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectChangeType(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-主体变更日志类型不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getObjectTypeCode(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-归属对象类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getObjectId(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-归属对象内容ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getReviseSubjectContent(), "D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-修订主体内容不能为空", false);
            implementReviseBaseChangeColComRespDto_1 = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto_1);


//processBranchName:正常结束 ,processBranchId:15403

        }
        JudgeSubjectLifeCycleBaseChangeColRespDto retData = new JudgeSubjectLifeCycleBaseChangeColRespDto();


        return retData;
    }

    /**
     * D1-判断重置修订元素[4343]
     * gen by moon at 10/2/2022, 6:30:40 AM
     */
    @Trace(operationName = "D1-判断重置修订元素")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeReviseElementRespDto judgeReviseElement(JudgeReviseElementReqDto reqDto) {


        List<ChangeColumn> listChangeColumn_1 = new ArrayList<>();
//步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:287679_1
        queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:287680_1
        queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:301459_1
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:287681_1
        if (reqDto != null) {
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:287677_1
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:287678_1
        }

        /*1-1-02查询底层变更字段列表[8]   */
        Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(), "D1-判断重置修订元素-1-1-02查询底层变更字段列表-内容表类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getEntityId(), "D1-判断重置修订元素-1-1-02查询底层变更字段列表-内容表主键ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getIsInproperties(), "D1-判断重置修订元素-1-1-02查询底层变更字段列表-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(), "D1-判断重置修订元素-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1-判断重置修订元素-1-1-02查询底层变更字段列表-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1-判断重置修订元素-1-1-02查询底层变更字段列表-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


        listChangeColumn_1 = listChangeColumn;

        JudgeReviseElementRespDto retData = new JudgeReviseElementRespDto();
        retData.setReviseElementList(listChangeColumn_1.stream().map(item -> item.getChangeColumnId())
                .collect(Collectors.toList()));/*list-to-strings*///sourceId:301460_1


        return retData;
    }

    /**
     * D1-1判断生命周期底层变更字段(公共)[4344]
     * gen by moon at 10/2/2022, 6:30:58 AM
     */
    @Trace(operationName = "D1-1判断生命周期底层变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeSubjectLifeCycleBaseChangeColComRespDto judgeSubjectLifeCycleBaseChangeColCom(JudgeSubjectLifeCycleBaseChangeColComReqDto reqDto) {


        if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("EDITING") && reqDto != null && reqDto.getBatchId() != null)) {
            //if((D1-1判断生命周期底层变更字段(公共).主体生命周期 等于 正在编辑 and D1-1判断生命周期底层变更字段(公共).批次ID 值不等于空 ))  15396

            ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto = null;
            ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto = new ImplementReviseBaseChangeColComReqDto();
            implementReviseBaseChangeColComReqDto.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:302192_1_15398
            implementReviseBaseChangeColComReqDto.setIsEditing("TRUE");//sourceId:302193_1_15398
            implementReviseBaseChangeColComReqDto.setSubjectLifeCycle("EDITING");//sourceId:302194_1_15398
            if (reqDto != null) {
                implementReviseBaseChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:302191_1_15398
                implementReviseBaseChangeColComReqDto.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:302195_1_15398
                implementReviseBaseChangeColComReqDto.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:302196_1_15398
                implementReviseBaseChangeColComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:302197_1_15398
                implementReviseBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:302198_1_15398
                implementReviseBaseChangeColComReqDto.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:302199_1_15398
                implementReviseBaseChangeColComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:302200_1_15398
                implementReviseBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:302201_1_15398
                implementReviseBaseChangeColComReqDto.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:302202_1_15398
                implementReviseBaseChangeColComReqDto.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:303944_1_15398
            }

            /*D1-1执行修订底层变更字段(批次下正在编辑)[272]   */
            Assert.isNull(implementReviseBaseChangeColComReqDto.getBatchId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-批次ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getBatchEndTime(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-批次结束时间不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getIsEditing(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-是否未来不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectLifeCycle(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-主体生命周期不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-主体类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectChangeType(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-主体变更日志类型不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getTableTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-内容表类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getEntityId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-内容表主键ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getEntityName(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-内容表主键行为日志英文名称不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getObjectTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-归属对象类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getObjectId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-归属对象内容ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto.getReviseSubjectContent(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-修订主体内容不能为空", false);
            implementReviseBaseChangeColComRespDto = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto);


//processBranchName:正常结束 ,processBranchId:15402

        } else if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID") && reqDto != null && reqDto.getBatchId() != null)) {
            //elseif((D1-1判断生命周期底层变更字段(公共).主体生命周期 等于 当前有效 and D1-1判断生命周期底层变更字段(公共).批次ID 值不等于空 ))  15397

            ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto_1 = null;
            ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto_1 = new ImplementReviseBaseChangeColComReqDto();
            implementReviseBaseChangeColComReqDto_1.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:302204_1_15399
            implementReviseBaseChangeColComReqDto_1.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:302205_1_15399
            implementReviseBaseChangeColComReqDto_1.setIsEditing("FALSE");//sourceId:302206_1_15399
            implementReviseBaseChangeColComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:302207_1_15399
            if (reqDto != null) {
                implementReviseBaseChangeColComReqDto_1.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:302203_1_15399
                implementReviseBaseChangeColComReqDto_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:302208_1_15399
                implementReviseBaseChangeColComReqDto_1.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:302209_1_15399
                implementReviseBaseChangeColComReqDto_1.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:302210_1_15399
                implementReviseBaseChangeColComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:302211_1_15399
                implementReviseBaseChangeColComReqDto_1.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:302212_1_15399
                implementReviseBaseChangeColComReqDto_1.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:302213_1_15399
                implementReviseBaseChangeColComReqDto_1.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:302214_1_15399
                implementReviseBaseChangeColComReqDto_1.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:302215_1_15399
                implementReviseBaseChangeColComReqDto_1.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:303945_1_15399
            }

            /*D1-1执行修订底层变更字段(批次下当前有效)[272]   */
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getBatchId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-批次ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getBatchStartTime(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-批次开始时间不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getBatchEndTime(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-批次结束时间不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getIsEditing(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-是否未来不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectLifeCycle(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-主体生命周期不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-主体类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectChangeType(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-主体变更日志类型不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getTableTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-内容表类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getEntityId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-内容表主键ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getEntityName(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-内容表主键行为日志英文名称不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getObjectTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-归属对象类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getObjectId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-归属对象内容ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_1.getReviseSubjectContent(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-修订主体内容不能为空", false);
            implementReviseBaseChangeColComRespDto_1 = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto_1);


//processBranchName:正常结束 ,processBranchId:15403

        } else if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("EDITING") && reqDto != null && reqDto.getBatchId() == null)) {
            //elseif((D1-1判断生命周期底层变更字段(公共).主体生命周期 等于 正在编辑 and D1-1判断生命周期底层变更字段(公共).批次ID 值等于空 ))  15538

            ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto_2 = null;
            ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto_2 = new ImplementReviseBaseChangeColComReqDto();
            implementReviseBaseChangeColComReqDto_2.setIsEditing("TRUE");//sourceId:302216_1_15540
            implementReviseBaseChangeColComReqDto_2.setSubjectLifeCycle("EDITING");//sourceId:302217_1_15540
            if (reqDto != null) {
                implementReviseBaseChangeColComReqDto_2.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:302218_1_15540
                implementReviseBaseChangeColComReqDto_2.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:302219_1_15540
                implementReviseBaseChangeColComReqDto_2.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:302220_1_15540
                implementReviseBaseChangeColComReqDto_2.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:302221_1_15540
                implementReviseBaseChangeColComReqDto_2.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:302222_1_15540
                implementReviseBaseChangeColComReqDto_2.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:302223_1_15540
                implementReviseBaseChangeColComReqDto_2.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:302224_1_15540
                implementReviseBaseChangeColComReqDto_2.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:302225_1_15540
                implementReviseBaseChangeColComReqDto_2.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:303946_1_15540
            }

            /*D1-1执行修订底层变更字段(无批次的正在编辑)[272]   */
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getIsEditing(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-是否未来不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getSubjectLifeCycle(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-主体生命周期不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getSubjectTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-主体类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getSubjectChangeType(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-主体变更日志类型不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getTableTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-内容表类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getEntityId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-内容表主键ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getEntityName(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-内容表主键行为日志英文名称不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getObjectTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-归属对象类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getObjectId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-归属对象内容ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_2.getReviseSubjectContent(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-修订主体内容不能为空", false);
            implementReviseBaseChangeColComRespDto_2 = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto_2);


//processBranchName:正常结束 ,processBranchId:15541

        } else if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID") && reqDto != null && reqDto.getBatchId() == null)) {
            //elseif((D1-1判断生命周期底层变更字段(公共).主体生命周期 等于 当前有效 and D1-1判断生命周期底层变更字段(公共).批次ID 值等于空 ))  15539

            ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto_3 = null;
            ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto_3 = new ImplementReviseBaseChangeColComReqDto();
            implementReviseBaseChangeColComReqDto_3.setIsEditing("FALSE");//sourceId:302229_1_15542
            implementReviseBaseChangeColComReqDto_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:302230_1_15542
            if (reqDto != null) {
                implementReviseBaseChangeColComReqDto_3.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:302231_1_15542
                implementReviseBaseChangeColComReqDto_3.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:302232_1_15542
                implementReviseBaseChangeColComReqDto_3.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:302233_1_15542
                implementReviseBaseChangeColComReqDto_3.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:302234_1_15542
                implementReviseBaseChangeColComReqDto_3.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:302235_1_15542
                implementReviseBaseChangeColComReqDto_3.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:302236_1_15542
                implementReviseBaseChangeColComReqDto_3.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:302237_1_15542
                implementReviseBaseChangeColComReqDto_3.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:302238_1_15542
                implementReviseBaseChangeColComReqDto_3.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:303947_1_15542
            }

            /*D1-1执行修订底层变更字段(无批次的当前有效)[272]   */
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getIsEditing(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-是否未来不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getSubjectLifeCycle(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-主体生命周期不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getSubjectTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-主体类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getSubjectChangeType(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-主体变更日志类型不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getTableTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-内容表类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getEntityId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-内容表主键ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getEntityName(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-内容表主键行为日志英文名称不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getObjectTypeCode(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-归属对象类型编码不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getObjectId(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-归属对象内容ID不能为空", false);
            Assert.isNull(implementReviseBaseChangeColComReqDto_3.getReviseSubjectContent(), "D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-修订主体内容不能为空", false);
            implementReviseBaseChangeColComRespDto_3 = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto_3);


//processBranchName:正常结束 ,processBranchId:15543

        }
        JudgeSubjectLifeCycleBaseChangeColComRespDto retData = new JudgeSubjectLifeCycleBaseChangeColComRespDto();


        return retData;
    }

    /**
     * D1修订组织批次下内容[4355]
     * gen by moon at 10/2/2022, 6:31:16 AM
     */
    @Trace(operationName = "D1修订组织批次下内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReviseOrgAtchContentRespDto reviseOrgAtchContent(ReviseOrgAtchContentReqDto reqDto) {


        //步骤0: D1-3查询个人就职记录信息详情（公共） - queryInductionRecordInfoDetailCom
        QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto = null;
        QueryInductionRecordInfoDetailComReqDto queryInductionRecordInfoDetailComReqDto = new QueryInductionRecordInfoDetailComReqDto();
        queryInductionRecordInfoDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:301556_1
        if (reqDto != null) {
            queryInductionRecordInfoDetailComReqDto.setInductionRecordId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:301546_1
        }

        /*D1-3查询个人就职记录信息详情（公共）[715]   */
        Assert.isNull(queryInductionRecordInfoDetailComReqDto.getInductionRecordId(), "D1修订组织批次下内容-D1-3查询个人就职记录信息详情（公共）-就职记录ID不能为空", false);
        Assert.isNull(queryInductionRecordInfoDetailComReqDto.getSpaceId(), "D1修订组织批次下内容-D1-3查询个人就职记录信息详情（公共）-创建于空间ID不能为空", false);
        queryInductionRecordInfoDetailComRespDto = inductionRecordService.queryInductionRecordInfoDetailCom(queryInductionRecordInfoDetailComReqDto);


//步骤1: 1-3-13修改就职记录 - updateInductionRecord
        boolean bOOLEAN;
        InductionRecord inductionRecord = new InductionRecord();
        inductionRecord.setIsUpdate("TRUE");//sourceId:301612_1
        inductionRecord.setUpdateStatus("REVISION");//sourceId:301613_1
        inductionRecord.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:301614_1
        inductionRecord.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:301615_1
        if (reqDto != null) {
            inductionRecord.setInductionRecordId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:301611_1
        }

        /*1-3-13修改就职记录（修改本次修订）[163]   */
        Assert.isNull(inductionRecord.getInductionRecordId(), "D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-就职记录ID不能为空", false);
        Assert.isNull(inductionRecord.getIsUpdate(), "D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-批次下是否更新不能为空", false);
        Assert.isNull(inductionRecord.getUpdateStatus(), "D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-批次下更新状态不能为空", false);
        Assert.isNull(inductionRecord.getOperationInductionId(), "D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-操作人就职记录ID不能为空", false);
        Assert.isNull(inductionRecord.getOperateTime(), "D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-操作时间不能为空", false);
        bOOLEAN = mInductionRecordService.updateInductionRecord(inductionRecord);


//步骤2: D1-1判断生命周期底层变更字段(公共) - judgeSubjectLifeCycleBaseChangeColCom
        JudgeSubjectLifeCycleBaseChangeColComRespDto judgeSubjectLifeCycleBaseChangeColComRespDto = null;
        if (queryInductionRecordInfoDetailComRespDto != null) {
            JudgeSubjectLifeCycleBaseChangeColComReqDto judgeSubjectLifeCycleBaseChangeColComReqDto = new JudgeSubjectLifeCycleBaseChangeColComReqDto();
            judgeSubjectLifeCycleBaseChangeColComReqDto.setSubjectLifeCycle("EDITING");//sourceId:301559_1
            judgeSubjectLifeCycleBaseChangeColComReqDto.setSubjectTypeCode("ORG_LOG_NAV");//sourceId:301563_1
            judgeSubjectLifeCycleBaseChangeColComReqDto.setSubjectChangeType("REVISE_REPORT_TO");//CUSTOM_CONVENTION//sourceId:301564_1
            judgeSubjectLifeCycleBaseChangeColComReqDto.setTableTypeCode("OMS_ORG_INDUCTION_RECORD");//sourceId:301565_1
            judgeSubjectLifeCycleBaseChangeColComReqDto.setEntityName("inductionRecordId");//CUSTOM_CONVENTION//sourceId:301566_1
            judgeSubjectLifeCycleBaseChangeColComReqDto.setObjectTypeCode("OMS_ORG_ORGANIZATION");//sourceId:301567_1
            if (reqDto != null) {
                judgeSubjectLifeCycleBaseChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:301558_1
                judgeSubjectLifeCycleBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:301560_1
                judgeSubjectLifeCycleBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:301561_1
                judgeSubjectLifeCycleBaseChangeColComReqDto.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:301568_1
            }
            if (queryInductionRecordInfoDetailComRespDto != null) {
                judgeSubjectLifeCycleBaseChangeColComReqDto.setReviseSubjectContent(queryInductionRecordInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:301562_1
            }

            /*D1-1判断生命周期底层变更字段(公共)[4344]   */
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getBatchId(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-批次ID不能为空", false);
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getSubjectLifeCycle(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-主体生命周期不能为空", false);
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getSubjectTypeCode(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-主体类型编码不能为空", false);
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getSubjectChangeType(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-主体变更日志类型不能为空", false);
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getTableTypeCode(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-内容表类型编码不能为空", false);
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getEntityId(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-内容表主键ID不能为空", false);
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getEntityName(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-内容表主键行为日志英文名称不能为空", false);
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getObjectTypeCode(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-归属对象类型编码不能为空", false);
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getObjectId(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-归属对象内容ID不能为空", false);
            Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getReviseSubjectContent(), "D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-修订主体内容不能为空", false);
            judgeSubjectLifeCycleBaseChangeColComRespDto = judgeSubjectLifeCycleBaseChangeColCom(judgeSubjectLifeCycleBaseChangeColComReqDto);


        }

        ReviseOrgAtchContentRespDto retData = new ReviseOrgAtchContentRespDto();


        return retData;
    }

    /**
     * D1批量回写底层变更字段(公共)[4382]
     * gen by moon at 9/20/2023, 11:29:12 PM
     */
    @Trace(operationName = "D1批量回写底层变更字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchWriteBackBaseChangeColComRespDto batchWriteBackBaseChangeColCom(BatchWriteBackBaseChangeColComReqDto reqDto) {


        //virtualUsage 1-1-02查询底层变更字段列表  15658
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        QueryBaseChangeColListReq queryBaseChangeColListReq = new QueryBaseChangeColListReq();
        queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:305680_1_15658
        queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:305682_1_15658
        queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:305675_1_15658
        if (reqDto != null) {
            queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:305674_1_15658
            queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:305672_1_15658
            queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:305673_1_15658
            queryBaseChangeColListReq.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:305694_1_15658
            queryBaseChangeColListReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:305695_1_15658
            queryBaseChangeColListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:305678_1_15658
        }

        /*1-1-02查询底层变更字段列表[8]   */
        Assert.isNull(queryBaseChangeColListReq.getObjectTypeCode(), "D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-归属对象类型编码不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getObjectId(), "D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-归属对象内容ID不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getIsInproperties(), "D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-是否内部属性不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(), "D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(), "D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-主体生命周期不能为空", false);
        Assert.isNull(queryBaseChangeColListReq.getSpaceId(), "D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空", false);
        listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage M1-1-02执行筛选更新字段主键（特殊方法）  15659
        //ModelCode: filterUpdateFieldPrimaryKey
        ImplementScreenUpdateFieldFkRespDto filterUpdateFieldPrimaryKeyRes = null;
        if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn.size() > 0) {
            ImplementScreenUpdateFieldFkReqDto filterUpdateFieldPrimaryKeyReq = new ImplementScreenUpdateFieldFkReqDto();
            if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn)) {
                filterUpdateFieldPrimaryKeyReq.setBaseChangeColumnList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.base.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:305859_1_15659
            }

            /*M1-1-02执行筛选更新字段主键（特殊方法）[4384]   */

            filterUpdateFieldPrimaryKeyRes = nbChangeColumn.implementScreenUpdateFieldFk(filterUpdateFieldPrimaryKeyReq);


        }
//virtualUsage M1-1-02执行拼接主表修订记录（特殊方法）  15670
        //ModelCode: concatenateMasterTableRevisionRecords
        ImplementSplicingMainTableRevisionRecordRespDto concatenateMasterTableRevisionRecordsRes = null;
        if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn.size() > 0) {
            ImplementSplicingMainTableRevisionRecordReqDto concatenateMasterTableRevisionRecordsReq = new ImplementSplicingMainTableRevisionRecordReqDto();
            if (listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn) && listChangeColumn != null && !CollectionUtil.isEmpty(listChangeColumn)) {
                concatenateMasterTableRevisionRecordsReq.setBaseChangeColumnList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.base.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:305894_1_15670
            }

            /*M1-1-02执行拼接主表修订记录（特殊方法）[4385]   */

            concatenateMasterTableRevisionRecordsRes = nbChangeColumn.implementSplicingMainTableRevisionRecord(concatenateMasterTableRevisionRecordsReq);


        }
        if ((filterUpdateFieldPrimaryKeyRes != null && filterUpdateFieldPrimaryKeyRes.getInductionRecordId() != null)) {
            //if(M1-1-02执行筛选更新字段主键（特殊方法）.就职记录ID 值不等于空 )  15660

            boolean bOOLEAN;
            List<InductionRecord> listInductionRecord = new ArrayList<>();
            if (concatenateMasterTableRevisionRecordsRes != null && concatenateMasterTableRevisionRecordsRes.getOrgInductionRecordList() != null && !CollectionUtil.isEmpty(concatenateMasterTableRevisionRecordsRes.getOrgInductionRecordList())) {
                listInductionRecord = concatenateMasterTableRevisionRecordsRes.getOrgInductionRecordList().stream().map(item -> BeanUtil.toBean(item, InductionRecord.class)).collect(Collectors.toList());//objList-to-objLists//sourceId:306133_1_15667
            }

            /*1-3-13批量修改就职记录[1647]   */

            bOOLEAN = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord)/*vcase invoke 本地 method 方法调用;*/;


        }
        if ((filterUpdateFieldPrimaryKeyRes != null && filterUpdateFieldPrimaryKeyRes.getDeptId() != null)) {
            //if(M1-1-02执行筛选更新字段主键（特殊方法）.部门ID 值不等于空 )  15664

            boolean bOOLEAN_1;
            List<Dept> listDept = new ArrayList<>();
            if (concatenateMasterTableRevisionRecordsRes != null && concatenateMasterTableRevisionRecordsRes.getDeptList() != null && !CollectionUtil.isEmpty(concatenateMasterTableRevisionRecordsRes.getDeptList())) {
                listDept = //objList-to-objLists
                        concatenateMasterTableRevisionRecordsRes.getDeptList().stream().map(item -> {
                            Dept elm = new Dept();
                            elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:94015_2_15668
                            elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:94016_2_15668
                            if (item != null) {
                                elm.setDeptId(item.getDeptId());//SimpleFieldAssign//sourceId:94006_2_15668
                                elm.setRoleMemberId(item.getRoleMemberId());//SimpleFieldAssign//sourceId:94007_2_15668
//elm.setDirectorInductionId(item.getDirectorInductionId());//SimpleFieldAssign//sourceId:94008_2_15668
                                elm.setDeptNumber(item.getDeptNumber());//SimpleFieldAssign//sourceId:94009_2_15668
                                elm.setDeptName(item.getDeptName());//SimpleFieldAssign//sourceId:94010_2_15668
                                elm.setDeptEnName(item.getDeptEnName());//SimpleFieldAssign//sourceId:94011_2_15668
                                elm.setDeptShortName(item.getDeptShortName());//SimpleFieldAssign//sourceId:94012_2_15668
                                elm.setDeptDutyDesc(item.getDeptDutyDesc());//SimpleFieldAssign//sourceId:94013_2_15668
                                elm.setDeptTargetDesc(item.getDeptTargetDesc());//SimpleFieldAssign//sourceId:94014_2_15668
                            }
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:306135_1_15668
            }

            /*1-3-09批量改部门[4387]   */

            bOOLEAN_1 = mDeptService.batchUpdateDept(listDept)/*vcase invoke 本地 method 方法调用;*/;


        }
        BatchWriteBackBaseChangeColComRespDto retData = new BatchWriteBackBaseChangeColComRespDto();


        return retData;
    }
    // @Resource
    // private DataSource dataSource;
    //
}
